diff --git a/.gitbook/assets/63f8d9a63907e9f382701bd1_BITCOIN.png b/.gitbook/assets/63f8d9a63907e9f382701bd1_BITCOIN.png
new file mode 100644
index 0000000..761d54a
Binary files /dev/null and b/.gitbook/assets/63f8d9a63907e9f382701bd1_BITCOIN.png differ
diff --git a/.gitbook/assets/Bitcoin.svg.png b/.gitbook/assets/Bitcoin.svg.png
new file mode 100644
index 0000000..8eea6bf
Binary files /dev/null and b/.gitbook/assets/Bitcoin.svg.png differ
diff --git a/.gitbook/assets/Btc2.png b/.gitbook/assets/Btc2.png
new file mode 100644
index 0000000..c8b7455
Binary files /dev/null and b/.gitbook/assets/Btc2.png differ
diff --git a/.gitbook/assets/Screenshot 2023-05-09 at 16.21.52.png b/.gitbook/assets/Screenshot 2023-05-09 at 16.21.52.png
new file mode 100644
index 0000000..03fbdb9
Binary files /dev/null and b/.gitbook/assets/Screenshot 2023-05-09 at 16.21.52.png differ
diff --git a/.gitbook/assets/Screenshot 2023-05-09 at 16.24.41.png b/.gitbook/assets/Screenshot 2023-05-09 at 16.24.41.png
new file mode 100644
index 0000000..4826f80
Binary files /dev/null and b/.gitbook/assets/Screenshot 2023-05-09 at 16.24.41.png differ
diff --git a/.gitbook/assets/image.png b/.gitbook/assets/image.png
new file mode 100644
index 0000000..ca3e171
Binary files /dev/null and b/.gitbook/assets/image.png differ
diff --git a/.gitbook/assets/logo.png b/.gitbook/assets/logo.png
new file mode 100644
index 0000000..45b7424
Binary files /dev/null and b/.gitbook/assets/logo.png differ
diff --git a/.gitbook/assets/openapi (1).yaml b/.gitbook/assets/openapi (1).yaml
new file mode 100644
index 0000000..1a0bb63
--- /dev/null
+++ b/.gitbook/assets/openapi (1).yaml
@@ -0,0 +1,221 @@
+openapi: 3.1.0
+servers:
+ - url: 'https://api.tatum.io'
+info:
+ version: 1.1.1
+ title: Data API
+tags:
+ - description: |
+ Tatum Data API is a comprehensive solution designed for developers to easily access on-chain data such as token balances, NFT owners, and metadata, all through a suite of user-friendly APIs.
+ With Tatum Data API, developers can seamlessly integrate blockchain functionality into their applications, enabling them to deliver innovative, web3 solutions. This powerful indexing solution supports multiple blockchains, ensuring developers have access to the latest data across different networks.
+ Tatum Data API offers a reliable, scalable, and cost-effective way for developers to access on-chain data, making it an essential tool for any blockchain project.
+ name: Data API
+paths:
+ /v3/data/collections:
+ get:
+ description: |
+ 10 credits per API call
+ Get all NFTs (ERC-721 and ERC-1155) and multitokens (ERC-1155 only) of your favorite collections! Our API lets you search for all tokens on:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - Provide a chain name and comma-separated list of collection addresses. Our API will return relevant information about each token, including its name, description, image, and more.
+ - Aside from relevant information about each token, the response also contains metadata (they can, however, be excluded by setting
excludeMetadata to true).
+ - If not specified, the API returns results for all supported types of tokens (nft, multitokens), but you can also choose to filter only one
tokenType.
+
+ operationId: GetCollections
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: |
+ The blockchain addresses of the collections.
+ It is possible to enter list of up to 10 addresses as a comma separated string.
+ in: query
+ name: collectionAddresses
+ required: true
+ schema:
+ type: string
+ example: '0x80d8bac9a6901698b3749fe336bbd1385c1f98f2'
+ - description: |
+ The option to select only specific token types.
+ It is possible to enter list of multiple types as a comma separated string.
+ Use nft (includes ERC-721 and ERC-1155) or multitoken (ERC-1155 only).
+ in: query
+ name: tokenTypes
+ schema:
+ type: string
+ example: 'nft'
+ enum:
+ - nft
+ - multitoken
+ - description: The option to exclude metadata from the response.
+ in: query
+ name: excludeMetadata
+ schema:
+ $ref: '#/components/schemas/ExcludeMetadata'
+ - description: The number of items per page (default is 50).
+ in: query
+ name: pageSize
+ schema:
+ $ref: '#/components/schemas/PageSize'
+ - description: The offset to obtain next page of the data.
+ in: query
+ name: offset
+ schema:
+ $ref: '#/components/schemas/Offset'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ type: object
+ properties:
+ chain:
+ $ref: '#/components/schemas/Chain'
+ tokenId:
+ $ref: '#/components/schemas/TokenId'
+ tokenAddress:
+ $ref: '#/components/schemas/TokenAddress'
+ tokenType:
+ $ref: '#/components/schemas/TokenType'
+ metadataURI:
+ $ref: '#/components/schemas/NftMetadataURI'
+ metadata:
+ $ref: '#/components/schemas/NftMetadata'
+ description: OK
+ 400: &API400
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error400'
+ description: Bad Request. Validation failed for the given object in the HTTP Body or Request parameters.
+ 401: &API401
+ content:
+ application/json:
+ schema:
+ oneOf:
+ - $ref: '#/components/schemas/Error401NotActive'
+ - $ref: '#/components/schemas/Error401Invalid'
+ description: Unauthorized. Not valid or inactive subscription key present in the HTTP Header.
+ 403: &API403
+ description: Forbidden. The request is authenticated, but it is not possible to required perform operation due to logical error or invalid permissions.
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error403'
+ 500: &API500
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error500'
+ description: Internal server error. There was an error on the server during the processing of the request.
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get tokens from a collection
+ tags:
+ - Data API
+components:
+ securitySchemes:
+ X-Api-Key:
+ description: |
+ To maintain the highest security level, Tatum requires X-API-Key HTTP header.
+ This X-API-Key represents identification of the plan and can be used by 1 developer or per environment.
+ Each X-API-Key is bound to the testnet or mainnet version of blockchains.
+ in: header
+ name: x-api-key
+ type: apiKey
+ schemas:
+ Chain:
+ type: string
+ description: Name of the chain.
+ example: 'ethereum-sepolia'
+ ChainEnum:
+ type: string
+ example: ethereum
+ enum:
+ - ethereum
+ - ethereum-sepolia
+ - celo
+ - celo-testnet
+ - bsc
+ - bsc-testnet
+ - polygon
+ - polygon-mumbai
+ ChainUtxoEnum:
+ type: string
+ example: bitcoin
+ enum:
+ - bitcoin
+ - bitcoin-testnet
+ - litecoin
+ - litecoin-testnet
+ - doge
+ - doge-testnet
+ - cardano
+ - cardano-preprod
+ TokenId:
+ type: string
+ description: ID of the token.
+ maxLength: 78
+ example: '123'
+ format: uint256
+ TokenAddress:
+ type: string
+ description: Contract address of the token.
+ example: '0x80d8bac9a6901698b3749fe336bbd1385c1f98f2'
+ TokenType:
+ type: string
+ description: Type of the token
+ example: 'nft'
+ ExcludeMetadata:
+ type: boolean
+ example: true
+ NftMetadataURI:
+ type: string
+ description: |
+ Metadata URL of the token. This data doesn't have to be present.
+ The safest way to obtain them in that case is from the NFT Contract.tokenURI() method call.
+ example: 'ipfs://QmXFpaS3S7CkLZvihLFA9JbawKdqhjg8dJeDkPntmkD2Pc'
+ NftMetadata:
+ type: object
+ description: |
+ Metadata scheme obtained from the url. This data don't have to be present.
+ The safest way to obtain them in that case is from the NFT Contract.tokenURI() method call.
+ example:
+ {
+ 'name': 'Example NFT name',
+ 'description': 'Example NFT description',
+ 'image': 'https://s3-us-east-1.amazonaws.com/example-image.jpg',
+ }
+ BlockNumber:
+ type: number
+ example: 16641547
+ minimum: 0
+ PageSize:
+ type: number
+ example: 10
+ minimum: 1
+ maximum: 50
+ Offset:
+ type: number
+ example: 1
+ PrevPage:
+ type: string
+ description: Cursor pagination, used to get previous page of results.
+ example: TBD
+ NextPage:
+ type: string
+ description: Cursor pagination, used to get next page of results.
+ example: TBD
diff --git a/.gitbook/assets/openapi (2).yaml b/.gitbook/assets/openapi (2).yaml
new file mode 100644
index 0000000..a680c91
--- /dev/null
+++ b/.gitbook/assets/openapi (2).yaml
@@ -0,0 +1,1523 @@
+openapi: 3.1.0
+servers:
+ - url: 'https://api.tatum.io'
+info:
+ version: 1.1.1
+ title: Data API
+tags:
+ - description: |
+ Tatum Data API is a comprehensive solution designed for developers to easily access on-chain data such as token balances, NFT owners, and metadata, all through a suite of user-friendly APIs.
+ With Tatum Data API, developers can seamlessly integrate blockchain functionality into their applications, enabling them to deliver innovative, web3 solutions. This powerful indexing solution supports multiple blockchains, ensuring developers have access to the latest data across different networks.
+ Tatum Data API offers a reliable, scalable, and cost-effective way for developers to access on-chain data, making it an essential tool for any blockchain project.
+ name: Data API
+paths:
+ /v3/data/collections:
+ get:
+ description: |
+ 10 credits per API call
+ Get all NFTs (ERC-721 and ERC-1155) and multitokens (ERC-1155 only) of your favorite collections! Our API lets you search for all tokens on:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - Provide a chain name and comma-separated list of collection addresses. Our API will return relevant information about each token, including its name, description, image, and more.
+ - Aside from relevant information about each token, the response also contains metadata (they can, however, be excluded by setting
excludeMetadata to true).
+ - If not specified, the API returns results for all supported types of tokens (nft, multitokens), but you can also choose to filter only one
tokenType.
+
+ operationId: GetCollections
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: |
+ The blockchain addresses of the collections.
+ It is possible to enter list of up to 10 addresses as a comma separated string.
+ in: query
+ name: collectionAddresses
+ required: true
+ schema:
+ type: string
+ example: '0x80d8bac9a6901698b3749fe336bbd1385c1f98f2'
+ - description: |
+ The option to select only specific token types.
+ It is possible to enter list of multiple types as a comma separated string.
+ Use nft (includes ERC-721 and ERC-1155) or multitoken (ERC-1155 only).
+ in: query
+ name: tokenTypes
+ schema:
+ type: string
+ example: 'nft'
+ enum:
+ - nft
+ - multitoken
+ - description: The option to exclude metadata from the response.
+ in: query
+ name: excludeMetadata
+ schema:
+ $ref: '#/components/schemas/ExcludeMetadata'
+ - description: The number of items per page (default is 50).
+ in: query
+ name: pageSize
+ schema:
+ $ref: '#/components/schemas/PageSize'
+ - description: The offset to obtain next page of the data.
+ in: query
+ name: offset
+ schema:
+ $ref: '#/components/schemas/Offset'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ type: object
+ properties:
+ chain:
+ $ref: '#/components/schemas/Chain'
+ tokenId:
+ $ref: '#/components/schemas/TokenId'
+ tokenAddress:
+ $ref: '#/components/schemas/TokenAddress'
+ tokenType:
+ $ref: '#/components/schemas/TokenType'
+ metadataURI:
+ $ref: '#/components/schemas/NftMetadataURI'
+ metadata:
+ $ref: '#/components/schemas/NftMetadata'
+ description: OK
+ 400: &API400
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error400'
+ description: Bad Request. Validation failed for the given object in the HTTP Body or Request parameters.
+ 401: &API401
+ content:
+ application/json:
+ schema:
+ oneOf:
+ - $ref: '#/components/schemas/Error401NotActive'
+ - $ref: '#/components/schemas/Error401Invalid'
+ description: Unauthorized. Not valid or inactive subscription key present in the HTTP Header.
+ 403: &API403
+ description: Forbidden. The request is authenticated, but it is not possible to required perform operation due to logical error or invalid permissions.
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error403'
+ 500: &API500
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/Error500'
+ description: Internal server error. There was an error on the server during the processing of the request.
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get tokens from a collection
+ tags:
+ - Data API
+ /v3/data/metadata:
+ get:
+ description: |
+ 5 credits per API call
+ Get metadata of NFTs (ERC-721 and ERC-1155) or multitokens (ERC-1155 only) by IDs for a given token address! Our API lets you search for all tokens on:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - Provide a chain name, token address and comma-separated list of IDs. Our API will return relevant metadata about each specified token, including its name, description, image, and more.
+ - Aside from the metadata information, the response also contains token types and metadata url minted in each token.
+
+ operationId: GetMetadata
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: The blockchain address of the NFT to get metadata for.
+ in: query
+ name: tokenAddress
+ required: true
+ schema:
+ $ref: '#/components/schemas/TokenAddress'
+ - description: |
+ The IDs of the tokens to get metadata for.
+ It is possible to enter list of multiple IDs as a comma separated string.
+ in: query
+ name: tokenIds
+ required: true
+ schema:
+ type: string
+ example: '90,123'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ type: object
+ properties:
+ chain:
+ $ref: '#/components/schemas/Chain'
+ tokenId:
+ $ref: '#/components/schemas/TokenId'
+ tokenAddress:
+ $ref: '#/components/schemas/TokenAddress'
+ tokenType:
+ $ref: '#/components/schemas/TokenType'
+ metadataURI:
+ $ref: '#/components/schemas/NftMetadataURI'
+ metadata:
+ $ref: '#/components/schemas/NftMetadata'
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get token metadata
+ tags:
+ - Data API
+ /v3/data/balances:
+ get:
+ description: |
+ 50 credits per API call
+ Get balances of fungible tokens (ERC-20), NFTs (ERC-721 and ERC-1155) or multitokens (ERC-1155 only) for a specific wallet address on the following blockchains:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - Provide a chain name and comma-separated list of addresses. Our API will return balances of each token along with further information such as its type, id, and more.
+ - Aside from relevant information about each token and its balance, the response also contains metadata (they can, however, be excluded by setting
excludeMetadata to true).
+ - If not specified, the API returns balances for all supported types of tokens (fungible tokens, nft, multitokens), but you can also choose to filter specific
tokenTypes.
+
+ operationId: GetBalances
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: |
+ The blockchain public wallet addresses.
+ It is possible to enter list of up to 10 addresses as a comma separated string.
+ in: query
+ name: addresses
+ required: true
+ schema:
+ type: string
+ description: Wallet address
+ example: '0x80d8bac9a6901698b3749fe336bbd1385c1f98f2,0xAe680Ed83baF08a8028118Bd19859F8a0E744cc6'
+ - description: |
+ The option to select only specific token types.
+ It is possible to enter list of multiple types as a comma separated string.
+ Use fungible (ERC-20), nft (includes ERC-721 and ERC-1155) or multitoken (ERC-1155 only).
+ in: query
+ name: tokenTypes
+ schema:
+ type: string
+ example: nft,multitoken
+ enum:
+ - nft
+ - multitoken
+ - fungible
+ - description: The option to exclude metadata from the response.
+ in: query
+ name: excludeMetadata
+ schema:
+ $ref: '#/components/schemas/ExcludeMetadata'
+ - description: The number of items per page (default is 50).
+ in: query
+ name: pageSize
+ schema:
+ $ref: '#/components/schemas/PageSize'
+ - description: The offset to obtain next page of the data.
+ in: query
+ name: offset
+ schema:
+ $ref: '#/components/schemas/Offset'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: object
+ properties:
+ result:
+ type: array
+ description: List of all balances for all selected tokens.
+ example:
+ [
+ {
+ 'chain': 'ethereum-mainnet',
+ 'address': '0xae680ed83baf08a8028118bd19859f8a0e744cc6',
+ 'balance': '283333333333333333333',
+ 'tokenAddress': '0x45dd18c5e0fa701abff449f6542aa53e258710b4',
+ 'lastUpdatedBlockNumber': 14792747,
+ 'type': 'fungible',
+ },
+ {
+ 'chain': 'ethereum-mainnet',
+ 'address': '0xae680ed83baf08a8028118bd19859f8a0e744cc6',
+ 'balance': '8690000000000000000',
+ 'tokenAddress': '0x090f21a84a0e9674c1828aca1db69ec8ae1454e8',
+ 'lastUpdatedBlockNumber': 15204015,
+ 'type': 'fungible',
+ },
+ {
+ 'chain': 'ethereum-mainnet',
+ 'address': '0xae680ed83baf08a8028118bd19859f8a0e744cc6',
+ 'balance': '1',
+ 'tokenAddress': '0xa58b5224e2fd94020cb2837231b2b0e4247301a6',
+ 'lastUpdatedBlockNumber': 15326272,
+ 'type': 'multitoken',
+ 'tokenId': '2605',
+ 'metadataURI': 'https://www.cryptovoxels.com/c/1/2605',
+ 'metadata':
+ {
+ 'url': 'https://www.cryptovoxels.com/c/1/2605',
+ 'name': 'Link Marine Helmet',
+ 'description': 'Chainlink Marine Helmet, give Sergey Nazarov your love.',
+ },
+ },
+ ]
+ prevPage:
+ $ref: '#/components/schemas/PrevPage'
+ nextPage:
+ $ref: '#/components/schemas/NextPage'
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get balances of addresses
+ tags:
+ - Data API
+ /v3/data/owners:
+ get:
+ description: |
+ 20 credits per API call
+ Get all addresses that own your favorite token (ERC-20, ERC-721 or ERC-1155)! Our API lets you search for all token owners on:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - Provide a chain name and address of any fungible token, NFT or multitoken collection. Our API will return a list of addresses of all of their owners.
+ - You can also get an owner of a specific NFT by specifying
tokenId. In case of multitoken, result is an array of addresses.
+
+ operationId: GetOwners
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: The blockchain address of the token (NFT collection or any fungible token).
+ in: query
+ name: tokenAddress
+ required: true
+ schema:
+ $ref: '#/components/schemas/TokenAddress'
+ - description: The ID of a specific NFT token.
+ in: query
+ name: tokenId
+ schema:
+ $ref: '#/components/schemas/TokenId'
+ - description: The number of items per page (default is 50).
+ in: query
+ name: pageSize
+ schema:
+ $ref: '#/components/schemas/PageSize'
+ - description: The offset to obtain next page of the data.
+ in: query
+ name: offset
+ schema:
+ $ref: '#/components/schemas/Offset'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: array
+ description: List of all addresses that own a token in a specified collection.
+ example:
+ [
+ "0x0bbf9f25c863fdf19e645c96280004d24f43cb38",
+ "0x0bd1b3b12db943f2310a4e53481ae97f8b6c2a75",
+ "0x281f4727081ab4a066f321fd6fc8dd0dc063e9fd",
+ "0x681cbae1c41e5eec8411dd8e009fa71f81d03f7f",
+ "0x7b49a05c15702bbe1db534058ebcc9e950c474ca",
+ ]
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get owners of a token
+ tags:
+ - Data API
+ /v3/data/owners/address:
+ get:
+ description: |
+ 1 credit per API call
+ Check if wallet address owns any specified token (ERC-20, ERC-721 or ERC-1155) on the following blockchains:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - Provide a chain name, wallet address and address of any fungible token, NFT or multitoken collection. Our API will return
true if provided wallet address owns them.
+ - If wallet address does not own the specific token, response body is
false and status code is 200.
+ - It is also possible to check if wallet address owns a specific NFT by specifying a
tokenId.
+
+ operationId: CheckOwner
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: The blockchain address of the wallet.
+ in: query
+ name: address
+ required: true
+ schema:
+ type: string
+ example: '0x10d8bac9a6901698b3749fe336bbd1385c1f98f2'
+ - description: The blockchain address of the token (NFT collection or any fungible token).
+ in: query
+ name: tokenAddress
+ required: true
+ schema:
+ $ref: '#/components/schemas/TokenAddress'
+ - description: The ID of a specific NFT token.
+ in: query
+ name: tokenId
+ schema:
+ $ref: '#/components/schemas/TokenId'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: boolean
+ example: true
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Check owner of token
+ tags:
+ - Data API
+ /v3/data/transactions:
+ get:
+ description: |
+ 20 credits per API call
+ Get transactions on the following blockchains:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - Provide a chain name and comma-separated list of addresses. Our API will return all of their transactions along with further information such as their block number, ID of involved token, and more.
+ - If not specified, the API returns transactions of various types (fungible, nft, multitoken, native, internal), but you can also choose to filter specific
transactionTypes and even transactionSubtype (incoming, outgoing, zero-transfer).
+ - On top of that, you can add further filters such as specifying block range where the transactions should have occurred, or address and ID of involved tokens.
+
+ operationId: GetTransactions
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: |
+ The blockchain public wallet addresses.
+ It is possible to enter list of up to 10 addresses as a comma separated string.
+ in: query
+ name: addresses
+ required: false
+ schema:
+ type: string
+ example: '0x80d8bac9a6901698b3749fe336bbd1385c1f98f2,0xAe680Ed83baF08a8028118Bd19859F8a0E744cc6'
+ - description: |
+ The option to filter transaction based on types.
+ It is possible to enter list of multiple types as a comma separated string.
+ Use fungible (ERC-20), nft (ERC-721 and ERC-1155), multitoken (ERC-1155), native or internal.
+ in: query
+ name: transactionTypes
+ schema:
+ type: string
+ example: fungible,nft
+ enum:
+ - fungible
+ - nft
+ - multitoken
+ - native
+ - internal
+ - description: The option to filter transaction based on subtype.
+ in: query
+ name: transactionSubtype
+ schema:
+ type: string
+ example: incoming
+ enum:
+ - incoming
+ - outgoing
+ - zero-transfer
+ - description: Address of a token (smart contract).
+ in: query
+ name: tokenAddress
+ schema:
+ $ref: '#/components/schemas/TokenAddress'
+ - description: ID of a token.
+ in: query
+ name: tokenId
+ required: false
+ schema:
+ $ref: '#/components/schemas/TokenId'
+ - description: Transactions from this block onwards will be included.
+ in: query
+ name: blockFrom
+ required: false
+ schema:
+ $ref: '#/components/schemas/BlockNumber'
+ - description: Transactions up to this block will be included.
+ in: query
+ name: blockTo
+ required: false
+ schema:
+ $ref: '#/components/schemas/BlockNumber'
+ - description: The number of items per page (default is 50).
+ in: query
+ name: pageSize
+ schema:
+ $ref: '#/components/schemas/PageSize'
+ - description: The offset to obtain next page of the data.
+ in: query
+ name: offset
+ schema:
+ $ref: '#/components/schemas/Offset'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: object
+ properties:
+ result:
+ type: array
+ description: List of all selected transactions.
+ example:
+ [
+ {
+ "chain": "ethereum-mainnet",
+ "hash": "0x549447710026cef714da21fb29cbfae1f689bd3246f2fa0a5081149c4aeb3bb3",
+ "address": "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+ "blockNumber": 16819465,
+ "transactionIndex": 84,
+ "transactionType": "fungible",
+ "transactionSubtype": "incoming",
+ "amount": "0.990923706372082143",
+ "timestamp": 1678715303000,
+ "tokenAddress": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+ "counterAddress": "0x0d4a11d5eeaac28ec3f61d100daf4d40471f1852"
+ },
+ {
+ "chain": "ethereum-mainnet",
+ "hash": "0x549447710026cef714da21fb29cbfae1f689bd3246f2fa0a5081149c4aeb3bb3",
+ "address": "0xdef1c0ded9bec7f1a1670819833240f027b25eff",
+ "blockNumber": 16819465,
+ "transactionIndex": 84,
+ "transactionType": "native",
+ "transactionSubtype": "zero-transfer",
+ "amount": "0",
+ "timestamp": 1678715303000,
+ "counterAddress": "0xd841e3d110cbe4aedb04c9dcc3572ec306bda2f9"
+ },
+ {
+ "chain": "ethereum-mainnet",
+ "hash": "0x4e0268c1e67575fd09047e006dd5ad26df402d85fa159e10639e9ea7c2d428f7",
+ "address": "0x0000000000000000000000000000000000000000",
+ "blockNumber": 16819465,
+ "transactionIndex": 119,
+ "transactionType": "nft",
+ "transactionSubtype": "outgoing",
+ "amount": "-1",
+ "timestamp": 1678715303000,
+ "tokenId": "33",
+ "tokenAddress": "0x3bcad8a734e923133d2c8c3fd4747d47e12d4f79",
+ "counterAddress": "0x84300dcc7ca9cf447e886fa17c11fa22557d1af0"
+ }
+ ]
+ prevPage:
+ $ref: '#/components/schemas/PrevPage'
+ nextPage:
+ $ref: '#/components/schemas/NextPage'
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get transactions
+ tags:
+ - Data API
+ /v3/data/transactions/hash:
+ get:
+ description: |
+ 5 credits per API call
+ Get transactions by hash on the following blockchains:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - Provide a chain name and transaction hash, and our API will return a list of transactions with that hash.
+ - The response will contain all the relevant information about specified transactions such as their block number, IDs of involved token, and more.
+
+ operationId: GetTransactionsByHash
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: Hash of the transaction.
+ in: query
+ name: hash
+ required: true
+ schema:
+ type: string
+ example: '0xd49f8d6544f2822522886a02f4787a56ea93bbd636bfdf81d6795a10553d7118'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: array
+ description: List of all transaction data.
+ example:
+ [
+ {
+ "chain": "ethereum-mainnet",
+ "hash": "0xd49f8d6544f2822522886a02f4787a56ea93bbd636bfdf81d6795a10553d7118",
+ "address": "0x9757f2d2b135150bbeb65308d4a91804107cd8d6",
+ "blockNumber": 16410533,
+ "transactionIndex": 139,
+ "transactionType": "native",
+ "transactionSubtype": "incoming",
+ "amount": "0.000000000000000039",
+ "timestamp": 1673765531000,
+ "counterAddress": "0x47405b78a7f381842c4f3d6b2d630dc390f3de9f"
+ },
+ {
+ "chain": "ethereum-mainnet",
+ "hash": "0xd49f8d6544f2822522886a02f4787a56ea93bbd636bfdf81d6795a10553d7118",
+ "address": "0x47405b78a7f381842c4f3d6b2d630dc390f3de9f",
+ "blockNumber": 16410533,
+ "transactionIndex": 139,
+ "transactionType": "native",
+ "transactionSubtype": "outgoing",
+ "amount": "-0.000000000000000039",
+ "timestamp": 1673765531000,
+ "counterAddress": "0x9757f2d2b135150bbeb65308d4a91804107cd8d6"
+ }
+ ]
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get transactions by hash
+ tags:
+ - Data API
+ /v3/data/events:
+ get:
+ description: |
+ 20 credits per API call
+ Get all events on given addresses and / or in the requested block range on the following blockchains:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - To improve response times and obtain specific data, it is recommended to use proper filtering techniques. Please provide a chain name and a combination of filters that will accomplish this (at least block range or contract addresses must be specified).
+ - It is possible to specify multiple contract addresses at once by passing them as a comma separated string.
+ - If block range is not specified, the API attempts to go through all available blocks, which may result in a timeout error.
+ - It is recommended to filter only one specific type of events, which comes with built-in decoding for all the supported types.
+ - It is, however, also possible to filter by signature hashes, which can be passed together as a comma separated string.
+
+ As noted above, aside from general info and hashed event data, the API also decodes them for you in case you filter by one of the following supported event types:
+
+ tokenTransfer: All transfers of fungible tokens (including stablecoins) and NFTs as per ERC-20 and ERC-721 standard.multitokenTransfer: All transfers of multitokens (both single transfers and batch transfers) as per ERC-1155 standard.stablecoinTransfer: Refers to the transfer of specific stablecoins on the mainnet. Typically, the top 10 to 16 stablecoins on each chain according to CoinMarketCap are included. If the contractAddresses parameter is also used in the filter combination, any tokens specified in it will also be included in the list.uniswapTrade: Provides all swap events that occur on both Uniswap V2 and V3. In some cases, it may not be possible to map the swapped amounts to specific tokens. As a result, certain decoded data such as token amounts might be missing or in the original big number format. This will be indicated by the response parameter partiallyRaw: true.
+ operationId: GetEvents
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: |
+ The blockchain addresses of the contracts where requested events were emitted.
+ It is possible to enter list of up to 10 addresses as a comma separated string.
+ in: query
+ name: contractAddresses
+ required: true
+ schema:
+ type: string
+ example: '0xd4307e0acd12cf46fd6cf93bc264f5d5d1598792'
+ - description: First block to start from (including this one).
+ in: query
+ name: blockFrom
+ required: true
+ schema:
+ $ref: '#/components/schemas/BlockNumber'
+ - description: Last block to finish on (including this one).
+ in: query
+ name: blockTo
+ required: true
+ schema:
+ $ref: '#/components/schemas/BlockNumber'
+ - description: |
+ The type of events that should be returned, which comes with decoded data in the response
+ (cannot be used together with signatures).
+ in: query
+ name: eventType
+ required: true
+ schema:
+ type: string
+ example: tokenTransfer
+ enum:
+ - tokenTransfer
+ - multitokenTransfer
+ - stablecoinTransfer
+ - uniswapTrade
+ - description: |
+ The types of events that should be returned, specified by hashed signature
+ (cannot be used together with eventType).
+ It is possible to enter list of multiple signatures as a comma separated string.
+ in: query
+ name: signatures
+ schema:
+ type: string
+ example: '0x0bcc4c97732e47d9946f229edb95f5b6323f601300e4690de719993f3c371129'
+ - description: The number of items per page (default is 50).
+ in: query
+ name: pageSize
+ schema:
+ $ref: '#/components/schemas/PageSize'
+ - description: The offset to obtain next page of the data.
+ in: query
+ name: offset
+ schema:
+ $ref: '#/components/schemas/Offset'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: array
+ examples:
+ tokenTransfer:
+ value:
+ [
+ {
+ "chain": "ethereum-mainnet",
+ "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+ "blockNumber": 16719956,
+ "timestamp": 1677506087000,
+ "decoded": {
+ "label": "Transfer(address,address,uint256)",
+ "type": "fungible",
+ "subtype": "transfer",
+ "from": "0xb4e16d0168e52d35cacd2c6185b44281ec28c9dc",
+ "to": "0xb3d994978d2bc50d2ce74c45fcd923e7c9c06730",
+ "decimals": 18,
+ "value": "0.030041143652018106"
+ },
+ "raw": {
+ "topic_0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "topic_1": "0x000000000000000000000000b4e16d0168e52d35cacd2c6185b44281ec28c9dc",
+ "topic_2": "0x000000000000000000000000b3d994978d2bc50d2ce74c45fcd923e7c9c06730",
+ "data": "0x000000000000000000000000000000000000000000000000006aba42d00667ba"
+ },
+ "txHash": "0x0ca14958f40d348bef24cd259a185c16867479b5f506e329063c4bb0b195a643",
+ "txIndex": 144,
+ "logIndex": 231
+ },
+ {
+ "chain": "ethereum-mainnet",
+ "address": "0xd4307e0acd12cf46fd6cf93bc264f5d5d1598792",
+ "blockNumber": 16719955,
+ "timestamp": 1677506075000,
+ "decoded": {
+ "label": "Transfer(address,address,uint256)",
+ "type": "nft",
+ "subtype": "mint",
+ "from": "0x0000000000000000000000000000000000000000",
+ "to": "0x192038b97fc5a926367f84743533ad63250be09b",
+ "tokenId": "370349"
+ },
+ "raw": {
+ "topic_0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "topic_1": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "topic_2": "0x000000000000000000000000192038b97fc5a926367f84743533ad63250be09b",
+ "topic_3": "0x000000000000000000000000000000000000000000000000000000000005a6ad"
+ },
+ "txHash": "0x52249e144a905e4e84f185ce4895dbd1c7b53fb9068461869e2c6dc7e2487296",
+ "txIndex": 99,
+ "logIndex": 177
+ }
+ ]
+ stablecoinTransfer:
+ value:
+ [
+ {
+ "chain": "ethereum-mainnet",
+ "address": "0xdac17f958d2ee523a2206206994597c13d831ec7",
+ "blockNumber": 16719958,
+ "timestamp": 1677506111000,
+ "decoded": {
+ "label": "Transfer(address,address,uint256)",
+ "type": "stablecoin",
+ "subtype": "transfer",
+ "from": "0x99de7724196070b9ff266adbac8c7abf56890207",
+ "to": "0xa9d1e08c7793af67e9d92fe308d5697fb81d3e43",
+ "decimals": 6,
+ "stablecoin": "USDT",
+ "value": "699.981164"
+ },
+ "raw": {
+ "topic_0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "topic_1": "0x00000000000000000000000099de7724196070b9ff266adbac8c7abf56890207",
+ "topic_2": "0x000000000000000000000000a9d1e08c7793af67e9d92fe308d5697fb81d3e43",
+ "data": "0x0000000000000000000000000000000000000000000000000000000029b8dd6c"
+ },
+ "txHash": "0xd77eaf324742498451aeafcfe4b2b9f07d817f6f6b0b1ae13fab5121b7bb32af",
+ "txIndex": 91,
+ "logIndex": 184
+ },
+ {
+ "chain": "ethereum-mainnet",
+ "address": "0xdac17f958d2ee523a2206206994597c13d831ec7",
+ "blockNumber": 16719947,
+ "timestamp": 1677505979000,
+ "decoded": {
+ "label": "Transfer(address,address,uint256)",
+ "type": "stablecoin",
+ "subtype": "transfer",
+ "from": "0x366cbca2412c2829fb80bfc844ed124938dd66c7",
+ "to": "0x28c6c06298d514db089934071355e5743bf21d60",
+ "decimals": 6,
+ "stablecoin": "USDT",
+ "value": "467727"
+ },
+ "raw": {
+ "topic_0": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "topic_1": "0x000000000000000000000000366cbca2412c2829fb80bfc844ed124938dd66c7",
+ "topic_2": "0x00000000000000000000000028c6c06298d514db089934071355e5743bf21d60",
+ "data": "0x0000000000000000000000000000000000000000000000000000006ce6b3a1c0"
+ },
+ "txHash": "0xb3aa57159446049acb1878b285452deb7fdcd798191472a3bae026006fc41fc7",
+ "txIndex": 66,
+ "logIndex": 69
+ }
+ ]
+ multitokenTransfer:
+ value:
+ [
+ {
+ "chain": "ethereum-mainnet",
+ "address": "0xd955e7bd8ca9f2aad391760f849cfa4ee2d80d57",
+ "blockNumber": 16719956,
+ "timestamp": 1677506087000,
+ "decoded": {
+ "label": "TransferSingle(address,address,address,uint256,uint256)",
+ "type": "multitoken",
+ "subtype": "transfer",
+ "from": "0x3dacc060c993ae03a7f956a4f8ff81a33fa75ea4",
+ "to": "0x5f8e0020c3164fb7eb170d7345672f6948ca0ff4",
+ "operator": "0x1e0049783f008a0085193e00003d00cd54003c71",
+ "multitokenId": "15",
+ "multitokenValue": "1"
+ },
+ "raw": {
+ "topic_0": "0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62",
+ "topic_1": "0x0000000000000000000000001e0049783f008a0085193e00003d00cd54003c71",
+ "topic_2": "0x0000000000000000000000003dacc060c993ae03a7f956a4f8ff81a33fa75ea4",
+ "topic_3": "0x0000000000000000000000005f8e0020c3164fb7eb170d7345672f6948ca0ff4",
+ "data": "0x000000000000000000000000000000000000000000000000000000000000000f0000000000000000000000000000000000000000000000000000000000000001"
+ },
+ "txHash": "0xd134d76b8a38a031bfad4bd7e1ee390ba610fa71cd66c338f1055260569ab643",
+ "txIndex": 180,
+ "logIndex": 349
+ },
+ {
+ "chain": "ethereum-mainnet",
+ "address": "0xd955e7bd8ca9f2aad391760f849cfa4ee2d80d57",
+ "blockNumber": 16719785,
+ "timestamp": 1677504011000,
+ "decoded": {
+ "label": "TransferBatch(address,address,address,uint256[],uint256[])",
+ "type": "multitoken",
+ "subtype": "mint",
+ "from": "0x0000000000000000000000000000000000000000",
+ "to": "0x1eb97e5c30c209e95913467fcc42c43274b0fe83",
+ "operator": "0x1eb97e5c30c209e95913467fcc42c43274b0fe83",
+ "multitokenIds": [
+ "26",
+ "21"
+ ],
+ "multitokenValues": [
+ "1",
+ "1"
+ ]
+ },
+ "raw": {
+ "topic_0": "0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb",
+ "topic_1": "0x0000000000000000000000001eb97e5c30c209e95913467fcc42c43274b0fe83",
+ "topic_2": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "topic_3": "0x0000000000000000000000001eb97e5c30c209e95913467fcc42c43274b0fe83",
+ "data": "0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000001a0000000000000000000000000000000000000000000000000000000000000015000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001"
+ },
+ "txHash": "0x2c4d5fa08d0d78cd08e3b2df66031f157d47d09dc931f0a0c967a086bd7dc593",
+ "txIndex": 135,
+ "logIndex": 395
+ }
+ ]
+ uniswapTrade:
+ value:
+ [
+ {
+ "chain": "ethereum-mainnet",
+ "address": "0x939da43b6987a1012a19db7bb971c9d88d409e2e",
+ "blockNumber": 16716951,
+ "timestamp": 1677469631000,
+ "decoded": {
+ "label": "Swap(address,uint256,uint256,uint256,uint256,address)",
+ "type": "uniswap",
+ "subtype": "v2",
+ "from": "0x68b3465833fb72a70ecdf485e0e4c7bd8665fc45",
+ "to": "0x29847b89f58cbf4749ab609c623cf4dadd703d68",
+ "token0": "0x80941467df667bfdad333d4dc3527713a620df3c",
+ "token1": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+ "amount0In": "0",
+ "amount1In": "0.02",
+ "amount0Out": "16.310991135231436277",
+ "amount1Out": "0"
+ },
+ "raw": {
+ "topic_0": "0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822",
+ "topic_1": "0x00000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45",
+ "topic_2": "0x00000000000000000000000029847b89f58cbf4749ab609c623cf4dadd703d68",
+ "data": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000470de4df820000000000000000000000000000000000000000000000000000e25c4804a603e5f50000000000000000000000000000000000000000000000000000000000000000"
+ },
+ "txHash": "0xd07727fa56151ed6813010859eaeaecb731a3da35b42583a720e60441e760dfb",
+ "txIndex": 105,
+ "logIndex": 316
+ },
+ {
+ "chain": "ethereum-mainnet",
+ "address": "0x939da43b6987a1012a19db7bb971c9d88d409e2e",
+ "blockNumber": 16716945,
+ "timestamp": 1677469520000,
+ "decoded": {
+ "label": "Swap(address,uint256,uint256,uint256,uint256,address)",
+ "type": "uniswap",
+ "subtype": "v2",
+ "from": "0x7a250d5630b4cf539739df2c5dacb4c659f2488d",
+ "to": "0xb90dd95cc9a8b603fa5b1ebf1fc54de792d51e44",
+ "token1": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+ "partiallyRaw": true,
+ "amount0In": "0",
+ "amount1In": "38582795937639190",
+ "amount0Out": "19346934115717712",
+ "amount1Out": "0"
+ },
+ "raw": {
+ "topic_0": "0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822",
+ "topic_1": "0x00000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45",
+ "topic_2": "0x00000000000000000000000029847b89f58cbf4749ab609c623cf4dadd703d68",
+ "data": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000470de4df820000000000000000000000000000000000000000000000000000e25c4804a603e5f50000000000000000000000000000000000000000000000000000000000000000"
+ },
+ "txHash": "0xd07727fa56151ed6813010859eaeaecb731a3da35b42583a720e60441e760dfb",
+ "txIndex": 77,
+ "logIndex": 421
+ },
+ {
+ "chain": "ethereum-mainnet",
+ "address": "0x8ad599c3a0ff1de082011efddc58f1908eb6e6d8",
+ "blockNumber": 16715826,
+ "timestamp": 1677455963000,
+ "decoded": {
+ "label": "Swap(address,address,int256,int256,uint160,uint128,int24)",
+ "type": "uniswap",
+ "subtype": "v3",
+ "from": "0xef1c6e67703c7bd7107eed8303fbe6ec2554bf6b",
+ "to": "0x2e8daf55f212be91d3fa882cceab193a08fddeb2",
+ "token0": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+ "token1": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+ "amount0": "2539.314198",
+ "amount1": "-1.545466196980525897",
+ "sqrtPriceX96": "1957504157831843308092484471058274",
+ "liquidity": "16050202700964797693",
+ "tick": 202307
+ },
+ "raw": {
+ "topic_0": "0xc42079f94a6350d7e6235f29174924f928cc2ac818eb64fed8004e115fbcca67",
+ "topic_1": "0x000000000000000000000000ef1c6e67703c7bd7107eed8303fbe6ec2554bf6b",
+ "topic_2": "0x0000000000000000000000002e8daf55f212be91d3fa882cceab193a08fddeb2",
+ "data": "0x00000000000000000000000000000000000000000000000000000000975adc16ffffffffffffffffffffffffffffffffffffffffffffffffea8d66ae9c9a14b700000000000000000000000000000000000060832d1059b69d1a2cc113896f62000000000000000000000000000000000000000000000000debdc651a4059cfd0000000000000000000000000000000000000000000000000000000000031643"
+ },
+ "txHash": "0x3cb892c1f046f8467a7e081aedbbf90eeca93fa96a892ebf6f3c5db191dc29f5",
+ "txIndex": 4,
+ "logIndex": 32
+ }
+ ]
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get specified events
+ tags:
+ - Data API
+ /v3/data/blocks:
+ get:
+ description: |
+ 10 credits per API call
+ Get information about blocks (when they were added, how many NFTs and events were ingested and list of transaction hashes that were processed within them) on the following blockchains:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started, provide a chain and specify one of the filters listed below (combination of these filters is not allowed):
+
+ - List of block numbers separated by comma
+ - Range of block numbers
+ - Date range when blocks were processed
+
+ operationId: GetBlocks
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: List of block numbers, separated by comma.
+ in: query
+ name: blockIds
+ schema:
+ type: array
+ items:
+ type: integer
+ example: 1,2,4,400
+ minimum: 0
+ - description: Range of block numbers. Both blockFrom and blockTo need to be specified.
+ in: query
+ name: blockFrom
+ schema:
+ $ref: '#/components/schemas/BlockNumber'
+ - description: Range of block numbers. Both blockFrom and blockTo need to be specified.
+ in: query
+ name: blockTo
+ schema:
+ $ref: '#/components/schemas/BlockNumber'
+ - description: Date range when blocks were processed. Both timeFrom and timeTo need to be specified.
+ in: query
+ name: timeFrom
+ schema:
+ type: string
+ example: '2022-12-24T00:10'
+ - description: Date range when blocks were processed. Both timeFrom and timeTo need to be specified.
+ in: query
+ name: timeTo
+ schema:
+ type: string
+ example: '2022-12-24T00:20'
+ - description: The number of items per page (default is 50).
+ in: query
+ name: pageSize
+ schema:
+ $ref: '#/components/schemas/PageSize'
+ - description: The offset to obtain next page of the data.
+ in: query
+ name: offset
+ schema:
+ $ref: '#/components/schemas/Offset'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: array
+ description: List of blocks added to a blockchain.
+ example:
+ [
+ {
+ "blockNumber": 10,
+ "blockTimestamp": 1598671520000,
+ "hash": "0xec1a2d906f34e1981b2b1a15dbe5e10cf640e8b4b27dc056ebb65c0409b5a9af",
+ "eventIngestedSize": 0,
+ "nftIngestedSize": 0
+ },
+ {
+ "blockNumber": 11,
+ "blockTimestamp": 1598671540000,
+ "hash": "0xa78e7a9c6910fea66a981389735e0c652f1625905c6e0dca08d3f5c1694b7cc4",
+ "eventIngestedSize": 1,
+ "nftIngestedSize": 0,
+ "txHashes": [
+ "0x19eaae1f7bdd28605f4175d7e87c9de68431bf76e85a262e268252a84bfc3984"
+ ]
+ }
+ ]
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get specified blocks
+ tags:
+ - Data API
+ /v3/data/blocks/latest:
+ get:
+ description: |
+ 1 credit per API call
+ Get information about latest added block on the following blockchains:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started, you can just provide a chain.
+ operationId: GetLatestBlock
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: object
+ description: Latest block added to a blockchain.
+ example:
+ {
+ "blockNumber": 25987956,
+ "blockTimestamp": 1677372871000,
+ "hash": "0x047a6ab09f86c760c145dc09b7a43b74d6ad957133ba4462a5530c642d4d9f17",
+ "eventIngestedSize": 351,
+ "nftIngestedSize": 7,
+ "txHashes": [
+ "0x01a7983d1391b74305840e4960ba6c61417a9398cb938c3522d0a4a9cedf488f",
+ "0x0478fdae7e5e6f1eb522e6f43ba760c924b1f72d16e4dadc332f150829d09cbe",
+ "0x05d00f08ae523e445c3b1e7bbabec1896091234643d50e8bcdb76ddd3ff3827a",
+ "0x0b644c19257cf34ab98c509c7901af5a4ad8c6f537b625b46ee771a45f1940dc",
+ "0x0c1016bf317946d9997588ee3b932bc8ba6033cfcb83eca4b5ebcc4f5eaa076d"
+ ]
+ }
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get latest block
+ tags:
+ - Data API
+ /v3/data/tokens:
+ get:
+ description: |
+ 1 credit per API call
+ Get information about your favorite token! Our API lets you search for all tokens on:
+
+ - Celo - celo / celo-testnet
+ - Ethereum - ethereum / ethereum-sepolia
+ - BNB (Binance) Smart Chain - bsc / bsc-testnet
+ - Polygon - polygon / polygon-mumbai
+
+ To get started:
+
+ - Provide a chain and address of any fungible token, NFT or multitoken collection. If available, our API will return information about them such as their name, symbol, supply, and more.
+ - You can also get extra infomation (such as metadata) of a specific NFT or multitoken by passing
tokenId as a query parameter.
+
+ operationId: GetTokens
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainEnum'
+ - description: The blockchain address of the token (NFT collection or any fungible token).
+ in: query
+ name: tokenAddress
+ required: true
+ schema:
+ $ref: '#/components/schemas/TokenAddress'
+ - description: The ID of a specific NFT token.
+ in: query
+ name: tokenId
+ schema:
+ $ref: '#/components/schemas/TokenId'
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: object
+ description: |
+ Information about specific collection or token
+ (not all fields are available for every token, e.g. some multitokens do not have name and symbol).
+ example:
+ {
+ "name": "BeefyCollectibles",
+ "symbol": "RareItem",
+ "tokenType": "nft",
+ "metadataURI": "QmYrUYv3kCXsrbs8YGguwZkyyMgGkgdQpbse8dZrDaruy5",
+ "metadata": {
+ "name": "Cowmmunity Ambassador",
+ "description": "Represents one of the most important roles in any civilization, as on him depends the molding of the community.",
+ "image": "QmbNsFNDCRYnswu5rtjTPNPkkn8y23DCXVkebrsx2b9fjg"
+ },
+ "supply": "13"
+ }
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 404:
+ description: Collection or token not found.
+ content:
+ application/json:
+ schema:
+ properties:
+ errorCode:
+ description: data-api.token
+ example: data-api.token
+ type: string
+ message:
+ description: Collection or token not found on chain ${chain}.
+ example: Collection or token not found on chain bsc-mainnet.
+ type: string
+ statusCode:
+ description: '404'
+ example: 404
+ type: number
+ required:
+ - errorCode
+ - message
+ - statusCode
+ type: object
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get information about collection or token
+ tags:
+ - Data API
+ /v3/data/utxos:
+ get:
+ description: |
+ 100 credits per API call
+ Get unspent UTXOs for a specific address up to a specific total amount.
+ If you want to prepare a transaction on UTXO-based chains like Bitcoin, you need to enter unspent UTXOs to be able to perform a transaction. By providing ```totalValue``` as a total, our API will return a list of UTXOs that will be enough to cover the transaction.
+ Our API lets you get the unpenst UTXOs for a specific address on:
+
+ - Bitcoin - bitcoin / bitcoin-testnet
+ - Litecoin - litecoin / litecoin-testnet
+ - Dogecoin - doge / doge-testnet
+ - Cardano - cardano / cardano-preprod
+
+ To get started:
+
+ - Provide a chain and address you want to list unspent UTXOs for. If available, our API will return information about the unspent UTXOs for a specific address. API traverses latest 200k incoming transactions.
+
+ operationId: GetUtxosByAddress
+ parameters:
+ - description: The blockchain to work with.
+ in: query
+ name: chain
+ required: true
+ schema:
+ $ref: '#/components/schemas/ChainUtxoEnum'
+ - description: The blockchain address.
+ in: query
+ name: address
+ required: true
+ schema:
+ type: string
+ example: bc1qmfp2r68cde646jv5ns7x2qvah8v5qtfw8gznj2
+ - description: The total amount of transaction you want to send. Only UTXOs up to this amount will be returned, so you will not spend more than you need.
+ in: query
+ name: totalValue
+ schema:
+ type: number
+ example: 0.0001
+ minimum: 0
+ responses:
+ 200:
+ content:
+ application/json:
+ schema:
+ type: array
+ description: |
+ Information about specific collection or token
+ (not all fields are available for every token, e.g. some multitokens do not have name and symbol).
+ items:
+ type: object
+ required:
+ - chain
+ - address
+ - txHash
+ - index
+ - value
+ properties:
+ chain:
+ $ref: '#/components/schemas/ChainUtxoEnum'
+ address:
+ type: string
+ description: Address of the UTXO
+ example: bc1qmfp2r68cde646jv5ns7x2qvah8v5qtfw8gznj2
+ txHash:
+ type: string
+ description: Hash of the transaction this UTXO is present in
+ example: '0x1b5b3e8a671434bf5d0d38e3e52dcafac484441a48bfae4a3f71e5b0b3093d8e'
+ index:
+ type: number
+ description: Index of the UTXO in the transaction
+ example: 0
+ value:
+ type: number
+ description: Value of the UTXO, in BTC, LTC or DOGE.
+ example: 0.0001
+ description: OK
+ 400:
+ <<: *API400
+ 401:
+ <<: *API401
+ 403:
+ <<: *API403
+ 500:
+ <<: *API500
+ security:
+ - X-API-Key: []
+ x-codeSamples: []
+ summary: Get unspent UTXOs for an address
+ tags:
+ - Data API
+
+components:
+ securitySchemes:
+ X-Api-Key:
+ description: |
+ To maintain the highest security level, Tatum requires X-API-Key HTTP header.
+ This X-API-Key represents identification of the plan and can be used by 1 developer or per environment.
+ Each X-API-Key is bound to the testnet or mainnet version of blockchains.
+ in: header
+ name: x-api-key
+ type: apiKey
+ schemas:
+ Chain:
+ type: string
+ description: Name of the chain.
+ example: 'ethereum-sepolia'
+ ChainEnum:
+ type: string
+ example: ethereum
+ enum:
+ - ethereum
+ - ethereum-sepolia
+ - celo
+ - celo-testnet
+ - bsc
+ - bsc-testnet
+ - polygon
+ - polygon-mumbai
+ ChainUtxoEnum:
+ type: string
+ example: bitcoin
+ enum:
+ - bitcoin
+ - bitcoin-testnet
+ - litecoin
+ - litecoin-testnet
+ - doge
+ - doge-testnet
+ - cardano
+ - cardano-preprod
+ TokenId:
+ type: string
+ description: ID of the token.
+ maxLength: 78
+ example: '123'
+ format: uint256
+ TokenAddress:
+ type: string
+ description: Contract address of the token.
+ example: '0x80d8bac9a6901698b3749fe336bbd1385c1f98f2'
+ TokenType:
+ type: string
+ description: Type of the token
+ example: 'nft'
+ ExcludeMetadata:
+ type: boolean
+ example: true
+ NftMetadataURI:
+ type: string
+ description: |
+ Metadata URL of the token. This data doesn't have to be present.
+ The safest way to obtain them in that case is from the NFT Contract.tokenURI() method call.
+ example: 'ipfs://QmXFpaS3S7CkLZvihLFA9JbawKdqhjg8dJeDkPntmkD2Pc'
+ NftMetadata:
+ type: object
+ description: |
+ Metadata scheme obtained from the url. This data don't have to be present.
+ The safest way to obtain them in that case is from the NFT Contract.tokenURI() method call.
+ example:
+ {
+ 'name': 'Example NFT name',
+ 'description': 'Example NFT description',
+ 'image': 'https://s3-us-east-1.amazonaws.com/example-image.jpg',
+ }
+ BlockNumber:
+ type: number
+ example: 16641547
+ minimum: 0
+ PageSize:
+ type: number
+ example: 10
+ minimum: 1
+ maximum: 50
+ Offset:
+ type: number
+ example: 1
+ PrevPage:
+ type: string
+ description: Cursor pagination, used to get previous page of results.
+ example: TBD
+ NextPage:
+ type: string
+ description: Cursor pagination, used to get next page of results.
+ example: TBD
diff --git a/.gitbook/assets/openapi.yaml b/.gitbook/assets/openapi.yaml
new file mode 100644
index 0000000..684012e
--- /dev/null
+++ b/.gitbook/assets/openapi.yaml
@@ -0,0 +1,168 @@
+openapi: 3.0.0
+info:
+ title: Sample API
+ description: Optional multiline or single-line description in [CommonMark](http://commonmark.org/help/) or HTML.
+ version: 0.1.9
+servers:
+ - url: https://tatum.io/api/v3/gas-pump
+paths:
+ /{owner}/{index}:
+ get:
+ summary: Get a Gas Pump address.
+ description: Returns a Gas Pump address.
+ parameters:
+ - name: index
+ in: path
+ description: Index of a address to get.
+ required: true
+ schema:
+ type: integer
+ format: int64
+ - name: owner
+ in: path
+ description: Owner of Gas Pump address.
+ required: true
+ schema:
+ type: string
+ responses:
+ "200": # status code
+ description: Gas Pump address.
+ content:
+ application/json:
+ schema:
+ $ref: "#/components/schemas/Address"
+ /{owner}/{from}/{to}:
+ get:
+ summary: Get a Gas Pump address.
+ description: Returns a Gas Pump addresses. Maximum number of returned addresses is limited to 10 000.
+ parameters:
+ - name: owner
+ in: path
+ description: Owner of Gas Pump address.
+ required: true
+ schema:
+ type: string
+ - name: from
+ in: path
+ description: Start index of a Gas Pump addresses to get.
+ required: true
+ schema:
+ type: integer
+ format: int64
+ minimum: 0
+ - name: to
+ in: path
+ description: End index of a Gas Pump addresses to get. To must be greater or equal to from parameter.
+ required: true
+ schema:
+ type: integer
+ format: int64
+ minimum: 0
+ responses:
+ "200": # status code
+ description: Gas Pump addresses.
+ content:
+ application/json:
+ schema:
+ type: array
+ items:
+ $ref: "#/components/schemas/Address"
+ '400':
+ description: Exceeded maximum number of Gas Pump addresses to generate. Please use lower number.
+ /activate/{owner}/{address}:
+ post:
+ summary: Activate Gas Pump address.
+ description: Activates transfers from Gas Pump address which was created by Gas Pump Address API call
+ parameters:
+ - name: owner
+ in: path
+ description: Owner of Gas Pump address.
+ required: true
+ schema:
+ type: string
+ - name: address
+ in: path
+ description: Address to activate trasnfers.
+ required: true
+ schema:
+ type: string
+ responses:
+ "201": # status code
+ description: OK
+ /activate/{owner}/{from}/{to}:
+ post:
+ summary: Activate Gas Pump addresses.
+ description: Activates transfers from Gas Pump addresses which was created by Gas Pump Address API call. Maximum number of activated addresses is different for every chain and it is dynamically calculated. Normal limit of how many addresses can be activated is described in following table TODO TABLE.
+ parameters:
+ - name: owner
+ in: path
+ description: Owner of Gas Pump address.
+ required: true
+ schema:
+ type: string
+ - name: from
+ in: path
+ description: Start index of a Gas Pump addresses to activate.
+ required: true
+ schema:
+ type: integer
+ format: int64
+ minimum: 0
+ - name: to
+ in: path
+ description: End index of a Gas Pump addresses to activate. To must be greater or equal to from parameter.
+ required: true
+ schema:
+ type: integer
+ format: int64
+ minimum: 0
+ responses:
+ "201": # status code
+ description: OK
+ '400':
+ description: Exceeded maximum number of Gas Pump addresses activations. Please lower number of addresses to activate.
+ /activated/{owner}/{address}:
+ get:
+ summary: Check if address is activated.
+ description: Check if address is activated to be able to transfer funds via Gas Pump.
+ parameters:
+ - name: owner
+ in: path
+ description: Owner of Gas Pump address.
+ required: true
+ schema:
+ type: string
+ - name: address
+ in: path
+ description: Address to check if it is activated.
+ required: true
+ schema:
+ type: string
+ responses:
+ "200": # status code
+ description: Whether Gas Pump address is activated.
+ content:
+ application/json:
+ schema:
+ $ref: "#/components/schemas/Activated"
+
+components:
+ schemas:
+ Address:
+ type: object
+ properties:
+ address:
+ type: string
+ description: Gas Pump address.
+ Activated:
+ type: object
+ properties:
+ activated:
+ type: boolean
+ description: True if address was already activated for gas pump transfer, otherwise false.
+ ExceededMaxLimitActivation:
+ type: object
+ properties:
+ error:
+ type: string
+ description: Exceeded maximum number of activation.
diff --git a/.gitbook/assets/wallet.png b/.gitbook/assets/wallet.png
new file mode 100644
index 0000000..3a86eaf
Binary files /dev/null and b/.gitbook/assets/wallet.png differ
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..71378ab
--- /dev/null
+++ b/README.md
@@ -0,0 +1,141 @@
+# ๐ฅณ Tatum Developer Documentation
+
+> We just released the new Tatum SDK which will make your web3 development flow super fun & you can read more about it here in docs.\
+> \
+> **Looking for our old documentation?** [**Click Here**](https://docs-v3.tatum.io)
+
+## Welcome to Tatum SDK! ๐
+
+Tatum SDK is here to make your life easier when building blockchain applications! No more complicated setups, no need for previous blockchain experience. We've got you covered.
+
+### Why Tatum SDK? ๐ก
+
+1. **Super fast development:** Start building blockchain applications in no time.
+2. **No previous blockchain experience required:** Perfect for beginners and experts alike.
+3. **One line of code:** Perform complex tasks with minimal effort.
+
+### Key Features ๐
+
+* Monitor activity on a blockchain address ๐ต๏ธโโ๏ธ
+* Perform RPC calls to various blockchains ๐
+* Read information about NFTs such as balances, transactions, or ownerships ๐ผ๏ธ
+* Get information about a specific wallet like balances or transaction history ๐ฐ
+
+### Get Started ๐
+
+To get started with Tatum SDK, simply run the following command based on the language of your choice:
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript SDK" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+npm install @tatumio/tatum
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Examples ๐
+
+Here are some quick examples to show you how easy it is to use Tatum SDK:
+
+#### Perform RPC calls
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+ const latestBlock = await tatum.rpc.blockNumber()
+ console.log(`Latest block is ${latestBlock}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+const { TatumSDK, Ethereum, Network } = require('@tatumio/tatum');
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM});
+ const latestBlock = await tatum.rpc.blockNumber();
+ console.log(`Latest block is ${latestBlock}`);
+})();
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+#### Monitor activity on a blockchain address
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+ const subscription = await tatum.notification.subscribe.incomingNativeTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you are subscribed for all incoming ETH transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+const { TatumSDK, Ethereum, Network } = require('@tatumio/tatum');
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM});
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d';
+ const subscription = await tatum.notification.subscribe.incomingNativeTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ });
+ console.log(`Now you are subscribed for all incoming ETH transactions on ${monitoredAddress}`);
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "INCOMING_NATIVE_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://"
+ }
+ }'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+Ready to build fantastic blockchain applications? Check out the official documentation for more information and examples!
+
+Happy coding! ๐
+
+{% hint style="info" %}
+### Join our Web3 Developer Community
+
+Get support with our products, meet other developers, and collaborate.\
+[Discord](https://discord.gg/tatum) ยท [Twitter](https://twitter.com/tatum\_io) ยท [Github](https://github.com/tatumio)
+{% endhint %}
diff --git a/SUMMARY.md b/SUMMARY.md
new file mode 100644
index 0000000..80f4684
--- /dev/null
+++ b/SUMMARY.md
@@ -0,0 +1,729 @@
+# Table of contents
+
+* [๐ฅณ Tatum Developer Documentation](README.md)
+* [๐ต Pricing](pricing.md)
+
+## โ Available SDKs
+
+* [Get started with Tatum SDK](sdk/get-started-with-tatum-sdk.md)
+* [JavaScript / TypeScript SDK](sdk/javascript-typescript-sdk/README.md)
+ * [Configuration options](sdk/javascript-typescript-sdk/configuration-options.md)
+ * [Submodules](sdk/javascript-typescript-sdk/submodules.md)
+* [Selecting the best SDK](sdk/selecting-the-best-sdk/README.md)
+ * [Full Comparison](sdk/selecting-the-best-sdk/full-comparison.md)
+ * [Provider Agnostic](sdk/selecting-the-best-sdk/provider-agnostic.md)
+ * [Chain Agnostic Response](sdk/selecting-the-best-sdk/chain-agnostic-response.md)
+
+## ๐ Documentation
+
+* [๐ฉ Notifications](docs/notifications/README.md)
+ * [Supported types and blockchain networks](docs/notifications/supported-types-and-blockchain-networks.md)
+ * [Notification workflow](docs/notifications/notification-workflow/README.md)
+ * [Start monitoring of the address](docs/notifications/notification-workflow/start-monitoring-of-the-address.md)
+ * [Stop monitoring of the address](docs/notifications/notification-workflow/stop-monitoring-of-the-address.md)
+ * [Get all sent notifications](docs/notifications/notification-workflow/get-all-sent-notifications.md)
+ * [Get all existing monitoring subscriptions](docs/notifications/notification-workflow/get-all-existing-monitoring-subscriptions.md)
+ * [Notification types](docs/notifications/notification-types/README.md)
+ * [Address event](docs/notifications/notification-types/address-event.md)
+ * [Incoming native transactions](docs/notifications/notification-types/incoming-native-transactions.md)
+ * [Outgoing native transactions](docs/notifications/notification-types/outgoing-native-transactions.md)
+ * [Incoming internal transactions](docs/notifications/notification-types/incoming-internal-transactions.md)
+ * [Outgoing internal transactions](docs/notifications/notification-types/outgoing-internal-transactions.md)
+ * [Outgoing failed transactions](docs/notifications/notification-types/outgoing-failed-transactions.md)
+ * [Failed transactions in a block](docs/notifications/notification-types/failed-transactions-in-a-block.md)
+ * [Paid fee](docs/notifications/notification-types/paid-fee.md)
+ * [Incoming Tokens](docs/notifications/notification-types/incoming-tokens.md)
+ * [Outgoing Tokens](docs/notifications/notification-types/outgoing-tokens.md)
+ * [Incoming NFTs](docs/notifications/notification-types/incoming-nfts.md)
+ * [Outgoing NFTs](docs/notifications/notification-types/outgoing-nfts.md)
+ * [Incoming MultiTokens](docs/notifications/notification-types/incoming-multitokens.md)
+ * [Outgoing MultiTokens](docs/notifications/notification-types/outgoing-multitokens.md)
+ * [Contract Address Log Event](docs/notifications/notification-types/contract-address-log-event.md)
+* [๐ต NFTs](docs/nfts/README.md)
+ * [Get all NFTs the wallet holds](docs/nfts/get-all-nfts-the-wallet-holds.md)
+ * [Get all NFTs in the NFT collection](docs/nfts/get-all-nfts-in-the-nft-collection.md)
+ * [Trace the history of a specific NFT](docs/nfts/trace-the-history-of-a-specific-nft.md)
+ * [Show the NFT history of a wallet](docs/nfts/show-the-nft-history-of-a-wallet.md)
+ * [Create NFT Collection](docs/nfts/create-nft-collection.md)
+ * [Create MultiToken NFT Collection](docs/nfts/create-multitoken-nft-collection.md)
+ * [Retrieve the owner of the NFT](docs/nfts/retrieve-the-owner-of-the-nft.md)
+ * [Check if the wallet owns a specific NFT](docs/nfts/check-if-the-wallet-owns-a-specific-nft.md)
+ * [Get the metadata of a specific NFT](docs/nfts/get-the-metadata-of-a-specific-nft.md)
+* [๐ช Fungible tokens](docs/fungible-tokens/README.md)
+ * [Get all fungible tokens the wallet holds](docs/fungible-tokens/get-all-fungible-tokens-the-wallet-holds.md)
+ * [Show fungible token history of a wallet](docs/fungible-tokens/show-fungible-token-history-of-a-wallet.md)
+ * [Get metadata of a fungible token](docs/fungible-tokens/get-metadata-of-a-fungible-token.md)
+ * [Create a fungible token](docs/fungible-tokens/create-a-fungible-token.md)
+* [โฝ Fee Estimation](docs/fee-estimation/README.md)
+ * [getCurrentFee](docs/fee-estimation/getcurrentfee.md)
+* [๐ฐ Wallet address operations](docs/wallet-address-operations/README.md)
+ * [Get all assets the wallet holds](docs/wallet-address-operations/get-all-assets-the-wallet-holds.md)
+ * [Get all transactions on the wallet](docs/wallet-address-operations/get-all-transactions-on-the-wallet.md)
+* [๐ป Wallet Provider](docs/wallet-provider/README.md)
+ * [MetaMask](docs/wallet-provider/metamask/README.md)
+ * [Connect a wallet](docs/wallet-provider/metamask/connect-a-wallet.md)
+ * [Transfer native assets](docs/wallet-provider/metamask/transfer-native-assets.md)
+ * [Transfer your NFT](docs/wallet-provider/metamask/transfer-your-nft.md)
+ * [Create your NFT Collection](docs/wallet-provider/metamask/create-your-nft-collection.md)
+ * [Create your Fungible Token](docs/wallet-provider/metamask/create-your-fungible-token.md)
+ * [Create your NFT (ERC-1155 MultiToken) Collection](docs/wallet-provider/metamask/create-your-nft-erc-1155-multitoken-collection.md)
+ * [Transfer fungible tokens like USDT](docs/wallet-provider/metamask/transfer-fungible-tokens-like-usdt.md)
+ * [Approve the transfer of a fungible token like USDT](docs/wallet-provider/metamask/approve-the-transfer-of-a-fungible-token-like-usdt.md)
+ * [Build your own custom transaction](docs/wallet-provider/metamask/build-your-own-custom-transaction.md)
+* [๐ฒ Exchange rates](docs/exchange-rates/README.md)
+ * [Get current exchange rate of the crypto asset](docs/exchange-rates/get-current-exchange-rate-of-the-crypto-asset.md)
+ * [Get current rates for multiple crypto assets at once](docs/exchange-rates/get-current-rates-for-multiple-crypto-assets-at-once.md)
+ * [Supported Crypto Currencies](docs/exchange-rates/supported-crypto-currencies.md)
+ * [Supported Fiats](docs/exchange-rates/supported-fiats.md)
+* [โ RPC](docs/rpc/README.md)
+ * [EVM Blockchains](docs/rpc/evm-blockchains/README.md)
+ * [Arbitrum RPC documentation](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/README.md)
+ * [Network state](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getcode.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/web3\_clientversion.md)
+ * [Transaction](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth\_sendrawtransaction.md)
+ * [Mempool](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/README.md)
+ * [txpool\_content](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool\_status.md)
+ * [Archival information](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/README.md)
+ * [debug\_getBadBlocks](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug\_getbadblocks.md)
+ * [debug\_traceCall](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug\_tracecall.md)
+ * [debug\_traceTransaction](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug\_tracetransaction.md)
+ * [debug\_traceBlockByHash](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug\_traceblockbyhash.md)
+ * [debug\_traceBlockByNumber](docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug\_traceblockbynumber.md)
+ * [Avalanche RPC documentation](docs/rpc/evm-blockchains/avalanche-rpc-documentation/README.md)
+ * [Network state](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getcode.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/web3\_clientversion.md)
+ * [Transaction](docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth\_sendrawtransaction.md)
+ * [Mempool](docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/README.md)
+ * [txpool\_content](docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool\_status.md)
+ * [Archival information](docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/README.md)
+ * [debug\_traceCall](docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug\_tracecall.md)
+ * [debug\_traceTransaction](docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug\_tracetransaction.md)
+ * [debug\_traceBlockByHash](docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug\_traceblockbyhash.md)
+ * [debug\_traceBlockByNumber](docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug\_traceblockbynumber.md)
+ * [BSC RPC documentation](docs/rpc/evm-blockchains/bsc-rpc-documentation/README.md)
+ * [Network state](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getcode.md)
+ * [eth\_call](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_call.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/web3\_clientversion.md)
+ * [Transaction](docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth\_sendrawtransaction.md)
+ * [Mempool](docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/README.md)
+ * [txpool\_content](docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool\_status.md)
+ * [Archival information](docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/README.md)
+ * [debug\_storageRangeAt](docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug\_storagerangeat.md)
+ * [debug\_traceCall](docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug\_tracecall.md)
+ * [debug\_traceTransaction](docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug\_tracetransaction.md)
+ * [debug\_traceBlockByHash](docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug\_traceblockbyhash.md)
+ * [debug\_traceBlockByNumber](docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug\_traceblockbynumber.md)
+ * [Ethereum RPC documentation](docs/rpc/evm-blockchains/ethereum-rpc-documentation/README.md)
+ * [Network state](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getcode.md)
+ * [eth\_call](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_call.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/web3\_clientversion.md)
+ * [Mempool](docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/README.md)
+ * [txpool\_content](docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool\_status.md)
+ * [Transaction](docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth\_sendrawtransaction.md)
+ * [Archival information](docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/README.md)
+ * [debug\_storageRangeAt](docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug\_storagerangeat.md)
+ * [debug\_traceCall](docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug\_tracecall.md)
+ * [eth\_getBlockReceipts](docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/eth\_getblockreceipts.md)
+ * [debug\_traceTransaction](docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug\_tracetransaction.md)
+ * [debug\_traceBlockByHash](docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug\_traceblockbyhash.md)
+ * [Flare RPC documentation](docs/rpc/evm-blockchains/flare-rpc-documentation/README.md)
+ * [Network state](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getcode.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/web3\_clientversion.md)
+ * [Transaction](docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth\_sendrawtransaction.md)
+ * [Archival information](docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/README.md)
+ * [debug\_storageRangeAt](docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug\_storagerangeat.md)
+ * [debug\_traceCall](docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug\_tracecall.md)
+ * [debug\_traceTransaction](docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug\_tracetransaction.md)
+ * [debug\_traceBlockByHash](docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug\_traceblockbyhash.md)
+ * [debug\_traceBlockByNumber](docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug\_traceblockbynumber.md)
+ * [debug\_getBadBlocks](docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug\_getbadblocks.md)
+ * [debug\_traceBlock](docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug\_traceblock.md)
+ * [Mempool](docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/README.md)
+ * [txpool\_content](docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool\_status.md)
+ * [Haqq RPC documentation](docs/rpc/evm-blockchains/haqq-rpc-documentation/README.md)
+ * [Network state](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getcode.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/web3\_clientversion.md)
+ * [Mempool](docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/README.md)
+ * [txpool\_content](docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool\_status.md)
+ * [Transaction](docs/rpc/evm-blockchains/haqq-rpc-documentation/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/evm-blockchains/haqq-rpc-documentation/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/evm-blockchains/haqq-rpc-documentation/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/evm-blockchains/haqq-rpc-documentation/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/evm-blockchains/haqq-rpc-documentation/transaction/eth\_sendrawtransaction.md)
+ * [Horizen EON RPC documentation](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/README.md)
+ * [Network state](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getcode.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/network-client-information/web3\_clientversion.md)
+ * [Transaction](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/transaction/eth\_sendrawtransaction.md)
+ * [Mempool](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/mempool/README.md)
+ * [txpool\_content](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/mempool/txpool\_status.md)
+ * [Archival information](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/archival-information/README.md)
+ * [debug\_traceCall](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/archival-information/debug\_tracecall.md)
+ * [debug\_traceTransaction](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/archival-information/debug\_tracetransaction.md)
+ * [debug\_traceBlockByHash](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/archival-information/debug\_traceblockbyhash.md)
+ * [debug\_traceBlockByNumber](docs/rpc/evm-blockchains/horizen-eon-rpc-documentation/archival-information/debug\_traceblockbynumber.md)
+ * [Optimism RPC documentation](docs/rpc/evm-blockchains/optimism-rpc-documentation/README.md)
+ * [Network state](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getcode.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/evm-blockchains/optimism-rpc-documentation/network-client-information/web3\_clientversion.md)
+ * [Mempool](docs/rpc/evm-blockchains/optimism-rpc-documentation/mempool/README.md)
+ * [txpool\_content](docs/rpc/evm-blockchains/optimism-rpc-documentation/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/evm-blockchains/optimism-rpc-documentation/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/evm-blockchains/optimism-rpc-documentation/mempool/txpool\_status.md)
+ * [Transaction](docs/rpc/evm-blockchains/optimism-rpc-documentation/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/evm-blockchains/optimism-rpc-documentation/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/evm-blockchains/optimism-rpc-documentation/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/evm-blockchains/optimism-rpc-documentation/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/evm-blockchains/optimism-rpc-documentation/transaction/eth\_sendrawtransaction.md)
+ * [Archival information](docs/rpc/evm-blockchains/optimism-rpc-documentation/archival-information/README.md)
+ * [debug\_storageRangeAt](docs/rpc/evm-blockchains/optimism-rpc-documentation/archival-information/debug\_storagerangeat.md)
+ * [debug\_traceCall](docs/rpc/evm-blockchains/optimism-rpc-documentation/archival-information/debug\_tracecall.md)
+ * [debug\_traceTransaction](docs/rpc/evm-blockchains/optimism-rpc-documentation/archival-information/debug\_tracetransaction.md)
+ * [debug\_traceBlockByHash](docs/rpc/evm-blockchains/optimism-rpc-documentation/archival-information/debug\_traceblockbyhash.md)
+ * [debug\_traceBlockByNumber](docs/rpc/evm-blockchains/optimism-rpc-documentation/archival-information/debug\_traceblockbynumber.md)
+ * [debug\_traceBlock](docs/rpc/evm-blockchains/optimism-rpc-documentation/archival-information/debug\_traceblock.md)
+ * [debug\_getBadBlocks](docs/rpc/evm-blockchains/optimism-rpc-documentation/archival-information/debug\_getbadblocks.md)
+ * [Polygon RPC documentation](docs/rpc/evm-blockchains/polygon-rpc-documentation/README.md)
+ * [Network state](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getcode.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/evm-blockchains/polygon-rpc-documentation/network-client-information/web3\_clientversion.md)
+ * [Mempool](docs/rpc/evm-blockchains/polygon-rpc-documentation/mempool/README.md)
+ * [txpool\_content](docs/rpc/evm-blockchains/polygon-rpc-documentation/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/evm-blockchains/polygon-rpc-documentation/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/evm-blockchains/polygon-rpc-documentation/mempool/txpool\_status.md)
+ * [Transaction](docs/rpc/evm-blockchains/polygon-rpc-documentation/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/evm-blockchains/polygon-rpc-documentation/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/evm-blockchains/polygon-rpc-documentation/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/evm-blockchains/polygon-rpc-documentation/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/evm-blockchains/polygon-rpc-documentation/transaction/eth\_sendrawtransaction.md)
+ * [Archival information](docs/rpc/evm-blockchains/polygon-rpc-documentation/archival-information/README.md)
+ * [debug\_storageRangeAt](docs/rpc/evm-blockchains/polygon-rpc-documentation/archival-information/debug\_storagerangeat.md)
+ * [debug\_traceCall](docs/rpc/evm-blockchains/polygon-rpc-documentation/archival-information/debug\_tracecall.md)
+ * [debug\_traceTransaction](docs/rpc/evm-blockchains/polygon-rpc-documentation/archival-information/debug\_tracetransaction.md)
+ * [debug\_traceBlockByHash](docs/rpc/evm-blockchains/polygon-rpc-documentation/archival-information/debug\_traceblockbyhash.md)
+ * [eth\_getBlockReceipts](docs/rpc/evm-blockchains/polygon-rpc-documentation/archival-information/eth\_getblockreceipts.md)
+ * [UTXO Blockchains](docs/rpc/utxo-blockchains/README.md)
+ * [Bitcoin RPC documentation](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/README.md)
+ * [Network state](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/README.md)
+ * [getbestblockhash](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/getbestblockhash.md)
+ * [getblockhash](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/getblockhash.md)
+ * [getblock](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/getblock.md)
+ * [getblockcount](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/getblockcount.md)
+ * [getblockchaininfo](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/getblockchaininfo.md)
+ * [getblockheader](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/getblockheader.md)
+ * [getblockstats](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/getblockstats.md)
+ * [getchaintips](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/getchaintips.md)
+ * [getdifficulty](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/getdifficulty.md)
+ * [gettxout](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/gettxout.md)
+ * [gettxoutproof](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/gettxoutproof.md)
+ * [verifytxoutproof](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/network-state/verifytxoutproof.md)
+ * [Transactions](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/transactions/README.md)
+ * [createrawtransaction](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/transactions/createrawtransaction.md)
+ * [sendrawtransaction](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/transactions/sendrawtransaction.md)
+ * [getrawtransaction](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/transactions/getrawtransaction.md)
+ * [estimatesmartfee](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/transactions/estimatesmartfee.md)
+ * [decoderawtransaction](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/transactions/decoderawtransaction.md)
+ * [decodescript](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/transactions/decodescript.md)
+ * [Mempool](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/mempool/README.md)
+ * [getmempoolancestors](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/mempool/getmempoolancestors.md)
+ * [getmempooldescendants](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/mempool/getmempooldescendants.md)
+ * [getmempoolentry](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/mempool/getmempoolentry.md)
+ * [getmempoolinfo](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/mempool/getmempoolinfo.md)
+ * [getrawmempool](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/mempool/getrawmempool.md)
+ * [Helper Functions](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/helper-functions/README.md)
+ * [validateaddress](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/helper-functions/validateaddress.md)
+ * [verifymessage](docs/rpc/utxo-blockchains/bitcoin-rpc-documentation/helper-functions/verifymessage.md)
+ * [Litecoin RPC documentation](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/README.md)
+ * [Network state](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/README.md)
+ * [getbestblockhash](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/getbestblockhash.md)
+ * [getblockhash](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/getblockhash.md)
+ * [getblock](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/getblock.md)
+ * [getblockcount](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/getblockcount.md)
+ * [getblockchaininfo](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/getblockchaininfo.md)
+ * [getblockheader](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/getblockheader.md)
+ * [getblockstats](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/getblockstats.md)
+ * [getchaintips](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/getchaintips.md)
+ * [getdifficulty](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/getdifficulty.md)
+ * [gettxout](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/gettxout.md)
+ * [gettxoutproof](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/gettxoutproof.md)
+ * [verifytxoutproof](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/network-state/verifytxoutproof.md)
+ * [Transactions](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/transactions/README.md)
+ * [createrawtransaction](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/transactions/createrawtransaction.md)
+ * [sendrawtransaction](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/transactions/sendrawtransaction.md)
+ * [getrawtransaction](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/transactions/getrawtransaction.md)
+ * [estimatesmartfee](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/transactions/estimatesmartfee.md)
+ * [decoderawtransaction](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/transactions/decoderawtransaction.md)
+ * [decodescript](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/transactions/decodescript.md)
+ * [Mempool](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/mempool/README.md)
+ * [getmempoolancestors](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/mempool/getmempoolancestors.md)
+ * [getmempooldescendants](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/mempool/getmempooldescendants.md)
+ * [getmempoolentry](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/mempool/getmempoolentry.md)
+ * [getmempoolinfo](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/mempool/getmempoolinfo.md)
+ * [getrawmempool](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/mempool/getrawmempool.md)
+ * [Helper Functions](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/helper-functions/README.md)
+ * [validateaddress](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/helper-functions/validateaddress.md)
+ * [verifymessage](docs/rpc/utxo-blockchains/litecoin-rpc-documentation/helper-functions/verifymessage.md)
+ * [Dogecoin RPC documentation](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/README.md)
+ * [Network state](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/README.md)
+ * [getbestblockhash](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/getbestblockhash.md)
+ * [getblockhash](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/getblockhash.md)
+ * [getblock](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/getblock.md)
+ * [getblockcount](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/getblockcount.md)
+ * [getblockchaininfo](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/getblockchaininfo.md)
+ * [getblockheader](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/getblockheader.md)
+ * [getchaintips](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/getchaintips.md)
+ * [getdifficulty](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/getdifficulty.md)
+ * [gettxout](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/gettxout.md)
+ * [gettxoutproof](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/gettxoutproof.md)
+ * [verifytxoutproof](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/network-state/verifytxoutproof.md)
+ * [Transactions](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/transactions/README.md)
+ * [createrawtransaction](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/transactions/createrawtransaction.md)
+ * [sendrawtransaction](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/transactions/sendrawtransaction.md)
+ * [getrawtransaction](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/transactions/getrawtransaction.md)
+ * [estimatesmartfee](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/transactions/estimatesmartfee.md)
+ * [decoderawtransaction](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/transactions/decoderawtransaction.md)
+ * [decodescript](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/transactions/decodescript.md)
+ * [Mempool](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/mempool/README.md)
+ * [getmempoolancestors](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/mempool/getmempoolancestors.md)
+ * [getmempooldescendants](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/mempool/getmempooldescendants.md)
+ * [getmempoolentry](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/mempool/getmempoolentry.md)
+ * [getmempoolinfo](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/mempool/getmempoolinfo.md)
+ * [getrawmempool](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/mempool/getrawmempool.md)
+ * [Helper Functions](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/helper-functions/README.md)
+ * [validateaddress](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/helper-functions/validateaddress.md)
+ * [verifymessage](docs/rpc/utxo-blockchains/dogecoin-rpc-documentation/helper-functions/verifymessage.md)
+ * [Solana RPC documentation](docs/rpc/solana-rpc-documentation/README.md)
+ * [Account information](docs/rpc/solana-rpc-documentation/account-information/README.md)
+ * [getAccountInfo](docs/rpc/solana-rpc-documentation/account-information/getaccountinfo.md)
+ * [getBalance](docs/rpc/solana-rpc-documentation/account-information/getbalance.md)
+ * [getLargestAccounts](docs/rpc/solana-rpc-documentation/account-information/getlargestaccounts.md)
+ * [getMultipleAccounts](docs/rpc/solana-rpc-documentation/account-information/getmultipleaccounts.md)
+ * [getProgramAccounts](docs/rpc/solana-rpc-documentation/account-information/getprogramaccounts.md)
+ * [getTokenAccountBalance](docs/rpc/solana-rpc-documentation/account-information/gettokenaccountbalance.md)
+ * [getTokenAccountsByDelegate](docs/rpc/solana-rpc-documentation/account-information/gettokenaccountsbydelegate.md)
+ * [getTokenAccountsByOwner](docs/rpc/solana-rpc-documentation/account-information/gettokenaccountsbyowner.md)
+ * [getVoteAccounts](docs/rpc/solana-rpc-documentation/account-information/getvoteaccounts.md)
+ * [Transactions](docs/rpc/solana-rpc-documentation/transactions/README.md)
+ * [getFeeForMessage](docs/rpc/solana-rpc-documentation/transactions/getfeeformessage.md)
+ * [getSignaturesForAddress](docs/rpc/solana-rpc-documentation/transactions/getsignaturesforaddress.md)
+ * [getSignatureStatuses](docs/rpc/solana-rpc-documentation/transactions/getsignaturestatuses.md)
+ * [getTransaction](docs/rpc/solana-rpc-documentation/transactions/gettransaction.md)
+ * [getTransactionCount](docs/rpc/solana-rpc-documentation/transactions/gettransactioncount.md)
+ * [isBlockhashValid](docs/rpc/solana-rpc-documentation/transactions/isblockhashvalid.md)
+ * [sendTransaction](docs/rpc/solana-rpc-documentation/transactions/sendtransaction.md)
+ * [simulateTransaction](docs/rpc/solana-rpc-documentation/transactions/simulatetransaction.md)
+ * [Token and Stake information](docs/rpc/solana-rpc-documentation/token-and-stake-information/README.md)
+ * [getInflationGovernor](docs/rpc/solana-rpc-documentation/token-and-stake-information/getinflationgovernor.md)
+ * [getInflationRate](docs/rpc/solana-rpc-documentation/token-and-stake-information/getinflationrate.md)
+ * [getInflationReward](docs/rpc/solana-rpc-documentation/token-and-stake-information/getinflationreward.md)
+ * [getStakeMinimumDelegation](docs/rpc/solana-rpc-documentation/token-and-stake-information/getstakeminimumdelegation.md)
+ * [getTokenLargestAccounts](docs/rpc/solana-rpc-documentation/token-and-stake-information/gettokenlargestaccounts.md)
+ * [getTokenSupply](docs/rpc/solana-rpc-documentation/token-and-stake-information/gettokensupply.md)
+ * [getStakeActivation](docs/rpc/solana-rpc-documentation/token-and-stake-information/getstakeactivation.md)
+ * [Ledger and block information](docs/rpc/solana-rpc-documentation/ledger-and-block-information/README.md)
+ * [getBlock](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getblock.md)
+ * [getBlockCommitment](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getblockcommitment.md)
+ * [getBlockHeight](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getblockheight.md)
+ * [getBlockProduction](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getblockproduction.md)
+ * [getBlocks](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getblocks.md)
+ * [getBlocksWithLimit](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getblockswithlimit.md)
+ * [getBlockTime](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getblocktime.md)
+ * [getFirstAvailableBlock](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getfirstavailableblock.md)
+ * [getHighestSnapshotSlot](docs/rpc/solana-rpc-documentation/ledger-and-block-information/gethighestsnapshotslot.md)
+ * [getGenesisHash](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getgenesishash.md)
+ * [getLatestBlockhash](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getlatestblockhash.md)
+ * [getLeaderSchedule](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getleaderschedule.md)
+ * [getSlot](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getslot.md)
+ * [getSlotLeader](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getslotleader.md)
+ * [getSlotLeaders](docs/rpc/solana-rpc-documentation/ledger-and-block-information/getslotleaders.md)
+ * [minimumLedgerSlot](docs/rpc/solana-rpc-documentation/ledger-and-block-information/minimumledgerslot.md)
+ * [Miscellaneous API calls](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/README.md)
+ * [getClusterNodes](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getclusternodes.md)
+ * [getHealth](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/gethealth.md)
+ * [getIdentity](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getidentity.md)
+ * [getVersion](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getversion.md)
+ * [getMaxRetransmitSlot](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getmaxretransmitslot.md)
+ * [getMaxShredInsertSlot](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getmaxshredinsertslot.md)
+ * [getMinimumBalanceForRentExemption](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getminimumbalanceforrentexemption.md)
+ * [getSupply](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getsupply.md)
+ * [getEpochInfo](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getepochinfo.md)
+ * [getEpochSchedule](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getepochschedule.md)
+ * [getRecentPerformanceSamples](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getrecentperformancesamples.md)
+ * [getRecentPrioritizationFees](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/getrecentprioritizationfees.md)
+ * [requestAirdrop](docs/rpc/solana-rpc-documentation/miscellaneous-api-calls/requestairdrop.md)
+ * [XRP RPC documentation](docs/rpc/xrp-rpc-documentation/README.md)
+ * [API calls for account methods](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/README.md)
+ * [account\_channels](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/account\_channels.md)
+ * [account\_currencies](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/account\_currencies.md)
+ * [account\_info](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/account\_info.md)
+ * [account\_lines](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/account\_lines.md)
+ * [account\_nfts](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/account\_nfts.md)
+ * [account\_objects](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/account\_objects.md)
+ * [account\_offers](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/account\_offers.md)
+ * [account\_tx](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/account\_tx.md)
+ * [gateway\_balances](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/gateway\_balances.md)
+ * [noripple\_check](docs/rpc/xrp-rpc-documentation/api-calls-for-account-methods/noripple\_check.md)
+ * [API calls for ledger methods](docs/rpc/xrp-rpc-documentation/api-calls-for-ledger-methods/README.md)
+ * [ledger](docs/rpc/xrp-rpc-documentation/api-calls-for-ledger-methods/ledger.md)
+ * [ledger\_closed](docs/rpc/xrp-rpc-documentation/api-calls-for-ledger-methods/ledger\_closed.md)
+ * [ledger\_current](docs/rpc/xrp-rpc-documentation/api-calls-for-ledger-methods/ledger\_current.md)
+ * [ledger\_data](docs/rpc/xrp-rpc-documentation/api-calls-for-ledger-methods/ledger\_data.md)
+ * [ledger\_entry](docs/rpc/xrp-rpc-documentation/api-calls-for-ledger-methods/ledger\_entry.md)
+ * [API calls for transaction methods](docs/rpc/xrp-rpc-documentation/api-calls-for-transaction-methods/README.md)
+ * [submit](docs/rpc/xrp-rpc-documentation/api-calls-for-transaction-methods/submit.md)
+ * [submit\_multisigned](docs/rpc/xrp-rpc-documentation/api-calls-for-transaction-methods/submit\_multisigned.md)
+ * [transaction\_entry](docs/rpc/xrp-rpc-documentation/api-calls-for-transaction-methods/transaction\_entry.md)
+ * [tx](docs/rpc/xrp-rpc-documentation/api-calls-for-transaction-methods/tx.md)
+ * [tx\_history](docs/rpc/xrp-rpc-documentation/api-calls-for-transaction-methods/tx\_history.md)
+ * [sign](docs/rpc/xrp-rpc-documentation/api-calls-for-transaction-methods/sign.md)
+ * [sign\_for](docs/rpc/xrp-rpc-documentation/api-calls-for-transaction-methods/sign\_for.md)
+ * [API calls for path and order book methods](docs/rpc/xrp-rpc-documentation/api-calls-for-path-and-order-book-methods/README.md)
+ * [book\_offers](docs/rpc/xrp-rpc-documentation/api-calls-for-path-and-order-book-methods/book\_offers.md)
+ * [deposit\_authorized](docs/rpc/xrp-rpc-documentation/api-calls-for-path-and-order-book-methods/deposit\_authorized.md)
+ * [nft\_buy\_offers](docs/rpc/xrp-rpc-documentation/api-calls-for-path-and-order-book-methods/nft\_buy\_offers.md)
+ * [nft\_sell\_offers](docs/rpc/xrp-rpc-documentation/api-calls-for-path-and-order-book-methods/nft\_sell\_offers.md)
+ * [ripple\_path\_find](docs/rpc/xrp-rpc-documentation/api-calls-for-path-and-order-book-methods/ripple\_path\_find.md)
+ * [API calls for payment channel methods](docs/rpc/xrp-rpc-documentation/api-calls-for-payment-channel-methods/README.md)
+ * [channel\_authorize](docs/rpc/xrp-rpc-documentation/api-calls-for-payment-channel-methods/channel\_authorize.md)
+ * [channel\_verify](docs/rpc/xrp-rpc-documentation/api-calls-for-payment-channel-methods/channel\_verify.md)
+ * [API calls for server info methods](docs/rpc/xrp-rpc-documentation/api-calls-for-server-info-methods/README.md)
+ * [fee](docs/rpc/xrp-rpc-documentation/api-calls-for-server-info-methods/fee.md)
+ * [server\_info](docs/rpc/xrp-rpc-documentation/api-calls-for-server-info-methods/server\_info.md)
+ * [server\_state](docs/rpc/xrp-rpc-documentation/api-calls-for-server-info-methods/server\_state.md)
+ * [manifest](docs/rpc/xrp-rpc-documentation/api-calls-for-server-info-methods/manifest.md)
+ * [API calls for utility methods](docs/rpc/xrp-rpc-documentation/api-calls-for-utility-methods/README.md)
+ * [ping](docs/rpc/xrp-rpc-documentation/api-calls-for-utility-methods/ping.md)
+ * [random](docs/rpc/xrp-rpc-documentation/api-calls-for-utility-methods/random.md)
+ * [TRON RPC documentation](docs/rpc/tron-rpc-documentation/README.md)
+ * [API calls for address utility methods](docs/rpc/tron-rpc-documentation/api-calls-for-address-utility-methods/README.md)
+ * [validateaddress](docs/rpc/tron-rpc-documentation/api-calls-for-address-utility-methods/validateaddress.md)
+ * [API calls for transaction methods](docs/rpc/tron-rpc-documentation/api-calls-for-transaction-methods/README.md)
+ * [broadcasttransaction](docs/rpc/tron-rpc-documentation/api-calls-for-transaction-methods/broadcasttransaction.md)
+ * [broadcasthex](docs/rpc/tron-rpc-documentation/api-calls-for-transaction-methods/broadcasthex.md)
+ * [createtransaction](docs/rpc/tron-rpc-documentation/api-calls-for-transaction-methods/createtransaction.md)
+ * [API calls for account methods](docs/rpc/tron-rpc-documentation/api-calls-for-account-methods/README.md)
+ * [createaccount](docs/rpc/tron-rpc-documentation/api-calls-for-account-methods/createaccount.md)
+ * [getaccount](docs/rpc/tron-rpc-documentation/api-calls-for-account-methods/getaccount.md)
+ * [updateaccount](docs/rpc/tron-rpc-documentation/api-calls-for-account-methods/updateaccount.md)
+ * [accountpermissionupdate](docs/rpc/tron-rpc-documentation/api-calls-for-account-methods/accountpermissionupdate.md)
+ * [getaccountbalance](docs/rpc/tron-rpc-documentation/api-calls-for-account-methods/getaccountbalance.md)
+ * [API calls for account resource methods](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/README.md)
+ * [getaccountresource](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/getaccountresource.md)
+ * [getaccountnet](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/getaccountnet.md)
+ * [freezebalance](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/freezebalance.md)
+ * [unfreezebalance](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/unfreezebalance.md)
+ * [getdelegatedresource](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/getdelegatedresource.md)
+ * [getdelegatedresourceaccountindex](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/getdelegatedresourceaccountindex.md)
+ * [freezebalancev2](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/freezebalancev2.md)
+ * [unfreezebalancev2](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/unfreezebalancev2.md)
+ * [delegateresource](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/delegateresource.md)
+ * [undelegateresource](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/undelegateresource.md)
+ * [withdrawexpireunfreeze](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/withdrawexpireunfreeze.md)
+ * [getavailableunfreezecount](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/getavailableunfreezecount.md)
+ * [getcanwithdrawunfreezeamount](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/getcanwithdrawunfreezeamount.md)
+ * [getcandelegatedmaxsize](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/getcandelegatedmaxsize.md)
+ * [getdelegatedresourcev2](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/getdelegatedresourcev2.md)
+ * [getdelegatedresourceaccountindexv2](docs/rpc/tron-rpc-documentation/api-calls-for-account-resource-methods/getdelegatedresourceaccountindexv2.md)
+ * [API calls for query the network methods](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/README.md)
+ * [getblock](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getblock.md)
+ * [getblockbynum](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getblockbynum.md)
+ * [getblockbyid](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getblockbyid.md)
+ * [getblockbylatestnum](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getblockbylatestnum.md)
+ * [getblockbylimitnext](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getblockbylimitnext.md)
+ * [getnowblock](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getnowblock.md)
+ * [gettransactionbyid](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/gettransactionbyid.md)
+ * [gettransactioninfobyid](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/gettransactioninfobyid.md)
+ * [gettransactioninfobyblocknum](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/gettransactioninfobyblocknum.md)
+ * [listnodes](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/listnodes.md)
+ * [getnodeinfo](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getnodeinfo.md)
+ * [getchainparameters](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getchainparameters.md)
+ * [getblockbalance](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getblockbalance.md)
+ * [getenergyprices](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getenergyprices.md)
+ * [getbandwidthprices](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getbandwidthprices.md)
+ * [getburntrx](docs/rpc/tron-rpc-documentation/api-calls-for-query-the-network-methods/getburntrx.md)
+ * [API calls for TRC10 token methods](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/README.md)
+ * [getassetissuebyaccount](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/getassetissuebyaccount.md)
+ * [getassetissuebyid](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/getassetissuebyid.md)
+ * [getassetissuebyname](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/getassetissuebyname.md)
+ * [getassetissuelist](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/getassetissuelist.md)
+ * [getassetissuelistbyname](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/getassetissuelistbyname.md)
+ * [getpaginatedassetissuelist](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/getpaginatedassetissuelist.md)
+ * [transferasset](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/transferasset.md)
+ * [createassetissue](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/createassetissue.md)
+ * [participateassetissue](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/participateassetissue.md)
+ * [unfreezeasset](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/unfreezeasset.md)
+ * [updateasset](docs/rpc/tron-rpc-documentation/api-calls-for-trc10-token-methods/updateasset.md)
+ * [API calls for smart contract methods](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/README.md)
+ * [getcontract](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/getcontract.md)
+ * [getcontractinfo](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/getcontractinfo.md)
+ * [triggersmartcontract](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/triggersmartcontract.md)
+ * [triggerconstantcontract](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/triggerconstantcontract.md)
+ * [deploycontract](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/deploycontract.md)
+ * [updatesetting](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/updatesetting.md)
+ * [updateenergylimit](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/updateenergylimit.md)
+ * [clearabi](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/clearabi.md)
+ * [estimateenergy](docs/rpc/tron-rpc-documentation/api-calls-for-smart-contract-methods/estimateenergy.md)
+ * [EVM methods](docs/rpc/tron-rpc-documentation/evm-methods/README.md)
+ * [Network state](docs/rpc/tron-rpc-documentation/evm-methods/network-state/README.md)
+ * [eth\_blockNumber](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_blocknumber.md)
+ * [eth\_getBlockByNumber](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getblockbynumber.md)
+ * [eth\_getBlockByHash](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getblockbyhash.md)
+ * [eth\_getTransactionByHash](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_gettransactionbyhash.md)
+ * [eth\_getTransactionReceipt](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_gettransactionreceipt.md)
+ * [eth\_getBalance](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getbalance.md)
+ * [eth\_getLogs](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getlogs.md)
+ * [eth\_getCode](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getcode.md)
+ * [eth\_getBlockTransactionCountByHash](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getblocktransactioncountbyhash.md)
+ * [eth\_getBlockTransactionCountByNumber](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getblocktransactioncountbynumber.md)
+ * [eth\_getStorageAt](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getstorageat.md)
+ * [eth\_getTransactionByBlockHashAndIndex](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_gettransactionbyblockhashandindex.md)
+ * [eth\_getTransactionByBlockNumberAndIndex](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_gettransactionbyblocknumberandindex.md)
+ * [eth\_getTransactionCount](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_gettransactioncount.md)
+ * [eth\_getProof](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getproof.md)
+ * [eth\_getUncleCountByBlockHash](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getunclecountbyblockhash.md)
+ * [eth\_getUncleCountByBlockNumber](docs/rpc/tron-rpc-documentation/evm-methods/network-state/eth\_getunclecountbyblocknumber.md)
+ * [Network/Client information](docs/rpc/tron-rpc-documentation/evm-methods/network-client-information/README.md)
+ * [eth\_chainId](docs/rpc/tron-rpc-documentation/evm-methods/network-client-information/eth\_chainid.md)
+ * [web3\_clientVersion](docs/rpc/tron-rpc-documentation/evm-methods/network-client-information/web3\_clientversion.md)
+ * [Transaction](docs/rpc/tron-rpc-documentation/evm-methods/transaction/README.md)
+ * [eth\_estimateGas](docs/rpc/tron-rpc-documentation/evm-methods/transaction/eth\_estimategas.md)
+ * [eth\_gasPrice](docs/rpc/tron-rpc-documentation/evm-methods/transaction/eth\_gasprice.md)
+ * [eth\_maxPriorityFeePerGas](docs/rpc/tron-rpc-documentation/evm-methods/transaction/eth\_maxpriorityfeepergas.md)
+ * [eth\_sendRawTransaction](docs/rpc/tron-rpc-documentation/evm-methods/transaction/eth\_sendrawtransaction.md)
+ * [Mempool](docs/rpc/tron-rpc-documentation/evm-methods/mempool/README.md)
+ * [txpool\_content](docs/rpc/tron-rpc-documentation/evm-methods/mempool/txpool\_content.md)
+ * [txpool\_inspect](docs/rpc/tron-rpc-documentation/evm-methods/mempool/txpool\_inspect.md)
+ * [txpool\_status](docs/rpc/tron-rpc-documentation/evm-methods/mempool/txpool\_status.md)
+ * [Archival information](docs/rpc/tron-rpc-documentation/evm-methods/archival-information/README.md)
+ * [debug\_traceCall](docs/rpc/tron-rpc-documentation/evm-methods/archival-information/debug\_tracecall.md)
+ * [debug\_traceTransaction](docs/rpc/tron-rpc-documentation/evm-methods/archival-information/debug\_tracetransaction.md)
+ * [debug\_traceBlockByHash](docs/rpc/tron-rpc-documentation/evm-methods/archival-information/debug\_traceblockbyhash.md)
+ * [debug\_traceBlockByNumber](docs/rpc/tron-rpc-documentation/evm-methods/archival-information/debug\_traceblockbynumber.md)
+
+***
+
+* [๐ v3 Features](v3-features/README.md)
+ * [NFT Express](https://docs-v3.tatum.io/nft-express/mint-nfts-with-tatums-nft-express)
+ * [API Reference](https://apidoc.tatum.io/)
+ * [Virtual Accounts](https://docs-v3.tatum.io/guides/ledger-and-off-chain)
+ * [Gas Pump](https://docs-v3.tatum.io/gas-pump/pay-gas-fees-with-tatum-gas-pump)
+ * [KMS](https://docs-v3.tatum.io/private-key-management/tatum-key-management-system-kms)
+
+## โ Learn Blockchain
+
+* [Basics](learn-blockchain/basics/README.md)
+ * [What is Blockchain?](learn-blockchain/basics/what-is-blockchain.md)
+ * [What is a Token on Blockchain?](learn-blockchain/basics/what-is-a-token-on-blockchain/README.md)
+ * [What are Native Tokens?](learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-native-tokens.md)
+ * [What are Fungible Tokens](learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-fungible-tokens.md)
+ * [What are Non Fungible Tokens?](learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-non-fungible-tokens.md)
+ * [What are MultiTokens?](learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-multitokens.md)
+ * [What are Transactions?](learn-blockchain/basics/what-are-transactions/README.md)
+ * [What are the reasons a transaction fails?](learn-blockchain/basics/what-are-transactions/what-are-the-reasons-a-transaction-fails.md)
+ * [What are Internal Transactions](learn-blockchain/basics/what-are-transactions/what-are-internal-transactions.md)
diff --git a/docs/exchange-rates/README.md b/docs/exchange-rates/README.md
new file mode 100644
index 0000000..78d45d0
--- /dev/null
+++ b/docs/exchange-rates/README.md
@@ -0,0 +1,19 @@
+---
+description: >-
+ Exchange rate submodule helps any web3 app developer to quickly query exchange
+ rate of a crypto against more than 165 fiat currencies.
+---
+
+# ๐ฒ Exchange rates
+
+The exchange rate submodule offers a powerful feature that enables users to obtain real-time exchange rates for a wide range of cryptocurrencies against more than 165 fiat currencies (see the full list on [Supported Fiat](supported-fiats.md) page) & more than 90 cryptocurrencies which you can find listed on [Supported Crypto Currencies](supported-crypto-currencies.md) page. This functionality can added better onboarding experience to new crypto users to keep them up-to-date with the Transaction Value they are most comfortable to read in.\
+\
+With the exchange rate submodule, developers can easily integrate this capability into their applications without the need for extensive knowledge of individual exchange APIs or complex rate calculation algorithms. Tatum SDK simplifies the process by providing a streamlined interface to retrieve exchange rates, allowing developers to focus on building robust and innovative applications.
+
+As a developer, the exchange rate submodule within our SDK offers you powerful capabilities to enhance your cryptocurrency applications. Here are the top three use cases you can get started building on:
+
+1. Portfolio Integration: Easily integrate real-time portfolio tracking into your application. With the exchange rate submodule, you can fetch and display the current values of users' cryptocurrency holdings, providing them with a comprehensive view of their investments.
+2. Seamless Currency Conversion: Simplify cryptocurrency-to-fiat conversions within your app. The exchange rate submodule allows you to retrieve accurate exchange rates, enabling users to convert cryptocurrencies seamlessly. Enhance the user experience by offering transparent and efficient currency conversion functionality.
+3. Merchant Integration: Seamlessly integrate cryptocurrency payment solutions for merchants. With the exchange rate submodule, you can fetch real-time exchange rates and display prices in users' preferred fiat currencies. Empower merchants to accept cryptocurrency payments with confidence and streamline transactions for their customers.
+
+Explore the possibilities and enhance user experience across your web3 application today.
diff --git a/docs/exchange-rates/get-current-exchange-rate-of-the-crypto-asset.md b/docs/exchange-rates/get-current-exchange-rate-of-the-crypto-asset.md
new file mode 100644
index 0000000..b49428b
--- /dev/null
+++ b/docs/exchange-rates/get-current-exchange-rate-of-the-crypto-asset.md
@@ -0,0 +1,68 @@
+---
+description: >-
+ This endpoint allows you to obtain current exchange rate between fiat/crypto
+ or fiat/fiat.
+---
+
+# Get current exchange rate of the crypto asset
+
+\
+The `getExchangeRate()` method offers a seamless way to retrieve up-to-date exchange rate information for cryptocurrencies. By invoking this method, you can effortlessly access the current exchange rate, along with the corresponding timestamp and the reliable source of the data.
+
+### How to use it
+
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init<Ethereum>({network: Network.ETHEREUM})
+
+const rate = await tatum.rates.getCurrentRate("BTC","EUR")
+
+
+{% embed url="https://codepen.io/tatum-devrel/pen/poQqQNB" %}
+
+### Request Interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+export class RateBatchDto {
+ // fiat
+ basePair: Fiat
+
+ // crypto currency/fiat
+ currency: Fiat | Currency
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+export class Rate {
+ // crypto currency/fiat
+ _id: Fiat | Currency
+
+ // the amount of basePair that can be exchanged for 1 _id (crypto currency/fiat)
+ value: string
+
+ // fiat
+ basePair: Fiat
+
+ // timestamp of rate information from source
+ timestamp: number
+
+ // source of rate
+ source: string
+}
+```
+{% endcode %}
+
+### Supported FIAT
+
+See the full wide range of fiat currencies we support for the exchange submodule on this [page](get-current-exchange-rate-of-the-crypto-asset.md#supported-fiat).
+
+### Supported Crypto Currency
+
+See the full wide range of crypto currencies we support for the exchange submodule on this [page](get-current-exchange-rate-of-the-crypto-asset.md#supported-crypto-currency).
diff --git a/docs/exchange-rates/get-current-rates-for-multiple-crypto-assets-at-once.md b/docs/exchange-rates/get-current-rates-for-multiple-crypto-assets-at-once.md
new file mode 100644
index 0000000..5b9572e
--- /dev/null
+++ b/docs/exchange-rates/get-current-rates-for-multiple-crypto-assets-at-once.md
@@ -0,0 +1,88 @@
+---
+description: >-
+ This endpoint allows you to obtain current exchange rates between fiat/crypto
+ or fiat/fiat.
+---
+
+# Get current rates for multiple crypto assets at once
+
+\
+The `getExchangeRates()` method in our API provides a powerful solution similar to the "Get current rate" method. It enables you to obtain current exchange rate information, along with timestamps and the source of the data. \
+\
+One notable feature of this method is the ability to request multiple exchange pairs simultaneously. This means you can retrieve exchange rates for various cryptocurrencies all in one API call, saving time and reducing complexity.
+
+### How to use it
+
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init<Ethereum>({network: Network.ETHEREUM})
+
+const rates = tatum.rates.getCurrentRateBatch(
+ [{
+ currency: "BTC",
+ basePair: "EUR",
+ batchId: "0"
+ }, {
+ currency: "ETH",
+ basePair: "EUR",
+ batchId: "1"
+ }])
+
+
+{% embed url="https://codepen.io/tatum-devrel/pen/xxQmQgV" %}
+
+### Request Interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// array of
+export class RateBatchDto {
+ // fiat
+ basePair: Fiat
+
+ // crypto currency/fiat
+ currency: Fiat | Currency
+
+ // used to identify pair in batch calls
+ batchId?: string
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// array of
+export class Rate {
+ // used to identify pair in batch calls
+ batchId?: string
+
+ // crypto currency/fiat
+ _id: Fiat | Currency
+
+ // the amount of basePair that can be exchanged for 1 _id (crypto currency/fiat)
+ value: string
+
+ // fiat
+ basePair: Fiat
+
+ // timestamp of rate information from source
+ timestamp: number
+
+ // source of rate
+ source: string
+}
+
+```
+{% endcode %}
+
+### Supported FIAT
+
+See the full wide range of fiat currencies we support for the exchange submodule on this [page](get-current-rates-for-multiple-crypto-assets-at-once.md#supported-fiat).
+
+### Supported Crypto Currency
+
+See the full wide range of crypto currencies we support for the exchange submodule on this [page](get-current-rates-for-multiple-crypto-assets-at-once.md#supported-crypto-currency).
diff --git a/docs/exchange-rates/supported-crypto-currencies.md b/docs/exchange-rates/supported-crypto-currencies.md
new file mode 100644
index 0000000..d0724d2
--- /dev/null
+++ b/docs/exchange-rates/supported-crypto-currencies.md
@@ -0,0 +1,108 @@
+---
+description: >-
+ This page lists all the cryptocurrencies Tatum supports for the Exchange rate
+ submodule.
+---
+
+# Supported Crypto Currencies
+
+Below is the list of Cryptocurrencies we supports for the Exchange Rate Submodule.
+
+```typescript
+export enum Currency {
+ BTC = 'BTC',
+ AVAX = 'AVAX',
+ FTM = 'FTM',
+ REVV = 'REVV',
+ SAND = 'SAND',
+ ADA = 'ADA',
+ BCH = 'BCH',
+ BNB = 'BNB',
+ LTC = 'LTC',
+ ONE = 'ONE',
+ ETH = 'ETH',
+ EGLD = 'EGLD',
+ MATIC = 'MATIC',
+ GAMEE = 'GAMEE',
+ MATIC_ETH = 'MATIC_ETH',
+ USDC_MATIC = 'USDC_MATIC',
+ USDC_BSC = 'USDC_BSC',
+ USDC_SOL = 'USDC_SOL',
+ RMD = 'RMD',
+ GMC = 'GMC',
+ GMC_BSC = 'GMC_BSC',
+ CELO = 'CELO',
+ COIIN = 'COIIN',
+ COIIN_BSC = 'COIIN_BSC',
+ CUSD = 'CUSD',
+ CEUR = 'CEUR',
+ FLOW = 'FLOW',
+ FUSD = 'FUSD',
+ BSC = 'BSC',
+ XDC = 'XDC',
+ DOGE = 'DOGE',
+ XRP = 'XRP',
+ XLM = 'XLM',
+ USDT = 'USDT',
+ TRON = 'TRON',
+ LEO = 'LEO',
+ LINK = 'LINK',
+ LISK = 'LISK',
+ FREE = 'FREE',
+ MKR = 'MKR',
+ USDC = 'USDC',
+ UNI = 'UNI',
+ BAT = 'BAT',
+ TUSD = 'TUSD',
+ PAX = 'PAX',
+ PLTC = 'PLTC',
+ XCON = 'XCON',
+ MMY = 'MMY',
+ PAXG = 'PAXG',
+ VET = 'VET',
+ HAG = 'HAG',
+ BETH = 'BETH',
+ BUSD = 'BUSD',
+ BBTC = 'BBTC',
+ BADA = 'BADA',
+ WBNB = 'WBNB',
+ BDOT = 'BDOT',
+ BXRP = 'BXRP',
+ BLTC = 'BLTC',
+ BBCH = 'BBCH',
+ CAKE = 'CAKE',
+ BUSD_BSC = 'BUSD_BSC',
+ B2U_BSC = 'B2U_BSC',
+ WBTC = 'WBTC',
+ USDT_TRON = 'USDT_TRON',
+ USDT_MATIC = 'USDT_MATIC',
+ LATOKEN = 'LATOKEN',
+ INRT_TRON = 'INRT_TRON',
+ ALGO = 'ALGO',
+ SOL = 'SOL',
+ KCS = 'KCS',
+ NEO = 'NEO',
+ KLAY = 'KLAY',
+ EOS = 'EOS',
+ ARB = 'ARB',
+ OPTIMISM = 'OPTIMISM',
+ NEAR = 'NEAR',
+ CRO = 'CRO',
+ RSK = 'RSK',
+ AURORA = 'AURORA',
+ GNO = 'GNO',
+ DOT = 'DOT',
+ KSM = 'KSM',
+ OASIS = 'OASIS',
+ TEZOS = 'TEZOS',
+ PALM = 'PALM',
+ GLMR = 'GLMR',
+ INTENT = 'INTENT',
+ EURTENT = 'EURTENT',
+ GOLDAX = 'GOLDAX',
+ ZCASH = 'ZCASH',
+ ZEC = 'ZEC',
+ ZIL = 'ZIL',
+ ETC = 'ETC',
+}
+```
diff --git a/docs/exchange-rates/supported-fiats.md b/docs/exchange-rates/supported-fiats.md
new file mode 100644
index 0000000..266c96f
--- /dev/null
+++ b/docs/exchange-rates/supported-fiats.md
@@ -0,0 +1,182 @@
+---
+description: >-
+ This page lists all the Fiat currencies Tatum supports for Exchange Rate
+ Submodule.
+---
+
+# Supported Fiats
+
+Below of the list of the fiats we support for the Exchange Rate Submodule.
+
+```typescript
+export enum Fiat {
+ AED = 'AED',
+ AFN = 'AFN',
+ ALL = 'ALL',
+ AMD = 'AMD',
+ ANG = 'ANG',
+ AOA = 'AOA',
+ ARS = 'ARS',
+ AUD = 'AUD',
+ AWG = 'AWG',
+ AZN = 'AZN',
+ BAM = 'BAM',
+ BBD = 'BBD',
+ BDT = 'BDT',
+ BGN = 'BGN',
+ BHD = 'BHD',
+ BIF = 'BIF',
+ BMD = 'BMD',
+ BND = 'BND',
+ BOB = 'BOB',
+ BRL = 'BRL',
+ BSD = 'BSD',
+ BTN = 'BTN',
+ BWP = 'BWP',
+ BYN = 'BYN',
+ BYR = 'BYR',
+ BZD = 'BZD',
+ CAD = 'CAD',
+ CDF = 'CDF',
+ CHF = 'CHF',
+ CLF = 'CLF',
+ CLP = 'CLP',
+ CNY = 'CNY',
+ COP = 'COP',
+ CRC = 'CRC',
+ CUC = 'CUC',
+ CUP = 'CUP',
+ CVE = 'CVE',
+ CZK = 'CZK',
+ DJF = 'DJF',
+ DKK = 'DKK',
+ DOP = 'DOP',
+ DZD = 'DZD',
+ EGP = 'EGP',
+ ERN = 'ERN',
+ ETB = 'ETB',
+ EUR = 'EUR',
+ FJD = 'FJD',
+ FKP = 'FKP',
+ GBP = 'GBP',
+ GEL = 'GEL',
+ GGP = 'GGP',
+ GHS = 'GHS',
+ GIP = 'GIP',
+ GMD = 'GMD',
+ GNF = 'GNF',
+ GTQ = 'GTQ',
+ GYD = 'GYD',
+ HKD = 'HKD',
+ HNL = 'HNL',
+ HRK = 'HRK',
+ HTG = 'HTG',
+ HUF = 'HUF',
+ IDR = 'IDR',
+ ILS = 'ILS',
+ IMP = 'IMP',
+ INR = 'INR',
+ IQD = 'IQD',
+ IRR = 'IRR',
+ ISK = 'ISK',
+ JEP = 'JEP',
+ JMD = 'JMD',
+ JOD = 'JOD',
+ JPY = 'JPY',
+ KES = 'KES',
+ KGS = 'KGS',
+ KHR = 'KHR',
+ KMF = 'KMF',
+ KPW = 'KPW',
+ KRW = 'KRW',
+ KWD = 'KWD',
+ KYD = 'KYD',
+ KZT = 'KZT',
+ LAK = 'LAK',
+ LBP = 'LBP',
+ LKR = 'LKR',
+ LRD = 'LRD',
+ LSL = 'LSL',
+ LTL = 'LTL',
+ LVL = 'LVL',
+ LYD = 'LYD',
+ MAD = 'MAD',
+ MDL = 'MDL',
+ MGA = 'MGA',
+ MKD = 'MKD',
+ MMK = 'MMK',
+ MNT = 'MNT',
+ MOP = 'MOP',
+ MRO = 'MRO',
+ MUR = 'MUR',
+ MVR = 'MVR',
+ MWK = 'MWK',
+ MXN = 'MXN',
+ MYR = 'MYR',
+ MZN = 'MZN',
+ NAD = 'NAD',
+ NGN = 'NGN',
+ NIO = 'NIO',
+ NOK = 'NOK',
+ NPR = 'NPR',
+ NZD = 'NZD',
+ OMR = 'OMR',
+ PAB = 'PAB',
+ PEN = 'PEN',
+ PGK = 'PGK',
+ PHP = 'PHP',
+ PKR = 'PKR',
+ PLN = 'PLN',
+ PYG = 'PYG',
+ QAR = 'QAR',
+ RON = 'RON',
+ RSD = 'RSD',
+ RUB = 'RUB',
+ RWF = 'RWF',
+ SAR = 'SAR',
+ SBD = 'SBD',
+ SCR = 'SCR',
+ SDG = 'SDG',
+ SEK = 'SEK',
+ SGD = 'SGD',
+ SHP = 'SHP',
+ SLL = 'SLL',
+ SOS = 'SOS',
+ SRD = 'SRD',
+ STD = 'STD',
+ SVC = 'SVC',
+ SYP = 'SYP',
+ SZL = 'SZL',
+ THB = 'THB',
+ TJS = 'TJS',
+ TMT = 'TMT',
+ TND = 'TND',
+ TOP = 'TOP',
+ TRY = 'TRY',
+ TTD = 'TTD',
+ TWD = 'TWD',
+ TZS = 'TZS',
+ UAH = 'UAH',
+ UGX = 'UGX',
+ USD = 'USD',
+ UYU = 'UYU',
+ UZS = 'UZS',
+ VEF = 'VEF',
+ VND = 'VND',
+ VUV = 'VUV',
+ WST = 'WST',
+ XAF = 'XAF',
+ XAG = 'XAG',
+ XAU = 'XAU',
+ XCD = 'XCD',
+ XDR = 'XDR',
+ XOF = 'XOF',
+ XPF = 'XPF',
+ YER = 'YER',
+ ZAR = 'ZAR',
+ ZMK = 'ZMK',
+ ZMW = 'ZMW',
+ ZWL = 'ZWL',
+}
+
+```
diff --git a/docs/fee-estimation/README.md b/docs/fee-estimation/README.md
new file mode 100644
index 0000000..08371ad
--- /dev/null
+++ b/docs/fee-estimation/README.md
@@ -0,0 +1,65 @@
+---
+description: >-
+ The Fee submodule is a part of the Tatum SDK, which allows developers to
+ interact with various blockchain networks. It specifically provides
+ functionalities related to retrieving gas fees.
+---
+
+# โฝ Fee Estimation
+
+## Introduction
+
+The Tatum Fee Submodule is a component of the Tatum SDK that provides a simple way to fetch and display the current gas fee for a specific blockchain network. Gas fees are a vital aspect of blockchain transactions, representing the cost required to execute operations on the network. By utilising this submodule, developers can easily retrieve and showcase the current gas fee for various blockchain networks, enabling better transparency and user experience within decentralised applications.
+
+## Get Started
+
+```javascript
+import { TatumSDK, Network, ApiVersion } from "@tatumio/tatum";
+
+// Initialize the Tatum SDK with the desired network and API version
+const tatum = await TatumSDK.init({ network: Network.ETHEREUM, version: ApiVersion.V1 });
+
+// Fetch the current gas fee
+const fee = await tatum.fee.getCurrentFee();
+
+// Display the fetched fee in console
+console.log(fee.data.gasPrice.fast);
+});
+
+```
+
+## Use Cases
+
+The Tatum Fee Submodule offers several use cases for developers working with blockchain networks. Some potential applications include:
+
+#### Transaction Cost Estimation
+
+Before executing a transaction on a blockchain network, it is essential to estimate the associated gas fee accurately. The Tatum Fee Submodule enables developers to fetch the current fee and use it to calculate the approximate transaction cost. This information allows users to make informed decisions and optimize their transaction parameters accordingly.
+
+#### User-Friendly Fee Display
+
+Displaying the current gas fee to end-users within a decentralised application can enhance their understanding of the transaction's cost. The Tatum Fee Submodule simplifies the process of fetching the fee and presenting it in a user-friendly format. Developers can integrate this functionality into their applications to show real-time gas fee updates, increasing transparency and facilitating user engagement.
+
+#### Gas Fee Comparison
+
+Comparing gas fees across different blockchain networks is crucial for users seeking the most cost-effective and efficient options. By utilising the Tatum Fee Submodule, developers can fetch and display fees from various supported networks simultaneously. This feature empowers users to evaluate and select networks based on current gas fees, enhancing the overall user experience.
+
+## Why it's tough to know Gas fees at a point of time
+
+Determining the precise gas fees at a particular moment can be challenging in the blockchain ecosystem due to several reasons:
+
+#### Dynamic Fee Market
+
+Blockchain networks often employ dynamic fee markets where fees fluctuate based on network congestion and demand. Gas fees are determined by a bidding process, where users compete to have their transactions included in the next block. As a result, gas fees can vary significantly within short timeframes, making it difficult to pinpoint the exact fee at any given point.
+
+#### Lack of Standardisation
+
+Different blockchain networks utilise varying fee models and calculation methods, further complicating the process of finding gas fees. Each network may have its own unit of measurement, fee structures, and mechanisms for determining transaction costs. This lack of standardisation makes it challenging to provide a unified approach to fetch gas fees across multiple networks.
+
+#### Network-Specific Implementations
+
+Fetching gas fees requires interacting with blockchain networks directly through their respective APIs or nodes. Each network may have its own specific implementation for retrieving fee data, including authentication requirements, rate limits, and API endpoints. Navigating these network-specific intricacies can be time-consuming and technically demanding for developers.
+
+The Tatum Fee Submodule addresses these challenges by providing a simplified and standardised interface to fetch gas fees from supported networks, allowing developers to focus on integrating fee-related functionalities into their applications without dealing with the complexities of individual networks.
+
+Note: The code provided in the initial question demonstrates a basic usage example of the Tatum Fee Submodule for fetching and displaying the current gas fee on the Ethereum network.
diff --git a/docs/fee-estimation/getcurrentfee.md b/docs/fee-estimation/getcurrentfee.md
new file mode 100644
index 0000000..350c973
--- /dev/null
+++ b/docs/fee-estimation/getcurrentfee.md
@@ -0,0 +1,111 @@
+---
+description: >-
+ This function fetches real-time gas fee data, including slow, medium, and fast
+ fees, based on the most recent recalculation, providing transparency for
+ blockchain transaction cost estimation.
+---
+
+# getCurrentFee
+
+## Overview
+
+The `getCurrentFee()` function is a method provided by the Tatum Fee Submodule in the Tatum SDK. It enables developers to fetch the current gas fee for a specific blockchain network. This function facilitates access to real-time fee information, allowing users to make informed decisions about transaction costs and optimize their blockchain interactions.
+
+#### Syntax
+
+```javascript
+const fee = await tatum.fee.getCurrentFee();
+```
+
+#### Note
+
+This function currently works with the previous version of our api & requires an explicit version initialisation for the main object to be called.
+
+```javascript
+// Some code
+const tatum = await TatumSDK.init(
+{ network: Network.ETHEREUM, version: ApiVersion.V3 }
+);
+```
+
+## Codepen
+
+{% embed url="https://codepen.io/tatum-devrel/pen/abQPQoz" %}
+
+## Response DTO
+
+```typescript
+interface CurrentEvmFee {
+ /* Chain for the Response */
+ chain: Network
+
+ /* gasPrice for slow, medium, fast, baseFee & unit */
+ gasPrice: {
+ slow: string
+ medium: string
+ fast: string
+ baseFee: string
+ unit: string
+ }
+
+ /* Last time when the gas fees was Recalculated */
+ lastRecalculated: string
+
+ /* This property specifies the block number or block
+ identifier on the blockchain network on which the current
+ gas fee data is based. */
+ basedOnBlockNumber: string
+}
+```
+
+#### Return Value
+
+The `getCurrentFee()` function returns a Promise that resolves to an object containing the current gas fee data for the selected network. The specific structure of the returned object may vary depending on the blockchain network and API version being used.
+
+#### Usage
+
+1. Initialise the Tatum SDK with the desired network and API version using `TatumSDK.init()`.
+
+```javascript
+const tatum = await TatumSDK.init({ network: Network.ETHEREUM, version: ApiVersion.V3 });
+```
+
+2. Call the `getCurrentFee()` function to fetch the current gas fee for the selected network.
+
+```javascript
+const fee = await tatum.fee.getCurrentFee();
+```
+
+3. Access the fee data returned by the function to retrieve the gas fee information.
+
+```javascript
+console.log(fee.data.gasPrice.fast); // Display the fast gas fee
+```
+
+## Supported blockchains
+
+* ETHEREUM
+* BITCOIN
+* LITECOIN
+* DOGECOIN
+
+## Example
+
+The following example demonstrates the usage of the `getCurrentFee()` function within an event listener:
+
+```javascript
+const button = document.getElementById("fetch-fee");
+const feeContainer = document.getElementById("fee-container");
+
+button.addEventListener("click", async () => {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM, version: ApiVersion.V3 });
+
+ const fee = await tatum.fee.getCurrentFee();
+
+ feeContainer.textContent = `Current Fee: ${fee.data.gasPrice.fast}`;
+});
+```
+
+In this example, when the "Fetch Fee" button is clicked, the `getCurrentFee()` function is called to fetch the current gas fee for the Ethereum network. The returned fee data is then used to update the content of the `feeContainer` element with the fast gas fee value.
+
+Note: The example assumes that the HTML structure and event listeners are properly set up as described in the previous sections. Adjust the code according to your specific requirements and chosen blockchain network.
diff --git a/docs/fungible-tokens/README.md b/docs/fungible-tokens/README.md
new file mode 100644
index 0000000..784b96b
--- /dev/null
+++ b/docs/fungible-tokens/README.md
@@ -0,0 +1,18 @@
+# ๐ช Fungible tokens
+
+Fungible tokens are a type of cryptographic token on the blockchain, which are interchangeable with each other, like traditional fiat currencies such as USD, EUR, or JPY. They are constructed using standard protocols like the ERC-20 for Ethereum, and they serve various purposes, from being used as a currency, to representing voting rights, and more. Fungibility implies that each unit of the token is exactly the same as every other unit.
+
+### Examples of Fungible Token Use Cases
+
+1. **Cryptocurrencies:** The most common application of fungible tokens is cryptocurrencies like Bitcoin (BTC) and Ether (ETH). In these systems, each individual token is identical to the next, ensuring any BTC or ETH token you own or receive will hold the same value as any other.
+2. **Utility Tokens:** Utility tokens offer users access to a product or service provided by a specific project or platform. An example of this is the Binance Coin (BNB). BNB is used on the Binance exchange platform for trading fees, participating in token sales, and more.
+3. #### Stablecoins
+
+ Stablecoins are a type of cryptocurrency designed to minimize volatility. They achieve this by pegging their value to a reserve of assets, typically fiat currencies like USD. Examples of stablecoins include Tether (USDT) and USD Coin (USDC).
+4. #### Governance Tokens
+
+ In Decentralized Autonomous Organizations (DAOs), governance tokens are used to grant holders voting rights within the community. One example is Maker (MKR). Holding MKR allows holders to participate in the governance of the Maker Protocol, voting on important issues such as risk parameters.
+5. #### Reward Tokens
+
+ Certain platforms offer reward tokens to incentivize user engagement or participation. An instance of this is Compound's COMP token, which is distributed to users as they interact with the protocol.
+
diff --git a/docs/fungible-tokens/create-a-fungible-token.md b/docs/fungible-tokens/create-a-fungible-token.md
new file mode 100644
index 0000000..00e3fec
--- /dev/null
+++ b/docs/fungible-tokens/create-a-fungible-token.md
@@ -0,0 +1,160 @@
+# Create a fungible token
+
+### Overview
+
+Creating a fungible token involves defining the parameters of the token, such as its name, symbol, and total supply, within a smart contract on a blockchain network like Ethereum. The distinguishing feature of fungible tokens, created using standards like ERC-20 or BEP-20, is their interchangeability. Each token is identical to the others in its set, meaning they can be exchanged on a one-for-one basis. This is in contrast to non-fungible tokens (NFTs), which are unique and not interchangeable, with each NFT representing a distinct asset or value.
+
+### How to create a fungible token on the Ethereum Sepolia network
+
+Use the TatumSDK (`@tatumio/tatum`) to create the token.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import { TatumSDK, Network, Ethereum, ResponseDto, TokenMetadata } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.token.createNewFungibleToken({
+ name: 'Test Token',
+ symbol: 'MY_TKN',
+ initialHolder: '0x48fa1676cfd0dfa23a71829c4c6d56874a88fa48',
+ initialSupply: '1000000',
+ owner: '0x48fa1676cfd0dfa23a71829c4c6d56874a88fa48',
+ })
+
+console.log(result)
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM_SEPOLIA });
+ const result = await tatum.token.createNewFungibleToken({
+ name: 'Test Token',
+ symbol: 'MY_TKN',
+ initialHolder: '0x48fa1676cfd0dfa23a71829c4c6d56874a88fa48',
+ initialSupply: '1000000',
+ owner: '0x48fa1676cfd0dfa23a71829c4c6d56874a88fa48',
+ })
+
+ console.log(result.data);
+ } catch (error) {
+ console.error("Error fetching token metadata:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request POST 'https://api.tatum.io/v4/contract/deploy?type=testnet' -H "Content-Type: application/json" -d '{"chain":"ethereum-sepolia","contractType":"fungible","name":"Test Token","symbol":"MY_TKN","initialHolder":"0x48fa1676cfd0dfa23a71829c4c6d56874a88fa48","initialSupply":"1000000","owner":"0x48fa1676cfd0dfa23a71829c4c6d56874a88fa48"}'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+
+
+Expected Response
+
+```json5
+{
+ "txId":"0x6f0ef980ee7c5289d10c8ee8cb5e1763ae72074d20424e2c3258f703c4ee7fba"
+}
+```
+
+
+
+### Use cases of fungible tokens include:
+
+* **Native Tokens for Platforms/Projects:** For example, Binance Coin (BNB) is the native token of Binance, serving both as a cryptocurrency and a utility token within the platform. It's used for transaction fees, participating in new token sales, and more.
+* **Stablecoins:** Tokens like USDT and USDC are examples of stablecoins, designed to maintain a stable value by being pegged to a reserve of assets, typically a fiat currency like USD. This provides stability in the volatile crypto markets.
+* **Governance Tokens:** Governance tokens, such as Maker (MKR), grant voting rights within a Decentralized Autonomous Organization (DAO). Holders of these tokens can vote on key aspects of the project, influencing its direction and policies.
+* **Reward Tokens:** Certain protocols, like Compound, use fungible tokens (in this case, COMP) as rewards to incentivise user engagement and participation within the platform. These tokens can also grant voting rights, enhancing the protocol's decentralised governance.
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface CreateFungibleToken {
+ /**
+ * Address of the fungible token owner
+ */
+ owner: string
+ /**
+ * Optional. Address of the fungible token minter, it defaults to the owner address
+ */
+ minter?: string
+ /**
+ * Optional. Address of the fungible token pauser, it defaults to the owner address
+ */
+ pauser?: string
+ /**
+ * Name of fungible token
+ */
+ name: string
+ /**
+ * Symbol of fungible token
+ */
+ symbol: string
+ /**
+ * Initial supply of fungible token
+ */
+ initialSupply: string
+ /**
+ * Initial holder of fungible token
+ */
+ initialHolder: string
+ /**
+ * Optional. Number of decimal places for the fungible token, it defaults to 18
+ */
+ decimals?: string
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response
+ */
+ data: T
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+
+interface TxIdResponse {
+ /**
+ * Id of the transaction
+ */
+ txId: string
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai
|
diff --git a/docs/fungible-tokens/get-all-fungible-tokens-the-wallet-holds.md b/docs/fungible-tokens/get-all-fungible-tokens-the-wallet-holds.md
new file mode 100644
index 0000000..b3793be
--- /dev/null
+++ b/docs/fungible-tokens/get-all-fungible-tokens-the-wallet-holds.md
@@ -0,0 +1,179 @@
+---
+description: >-
+ This function helps you to fetch all the fungible tokens a wallet holds, all
+ you have to do is pass the address to the function parameter and chain while
+ initialising the sdk.
+---
+
+# Get all fungible tokens the wallet holds
+
+### Overview
+
+The "Get all fungible tokens the wallet holds" function is designed to retrieve information about all the fungible tokens stored in a specific wallet. By providing the wallet address as a parameter and initialising the software development kit (SDK) with the appropriate blockchain, this function enables users to fetch data regarding the fungible tokens associated with that particular wallet.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/gOQZjjj" %}
+
+### How to get fungible tokens on a wallet in the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get a balance of the wallet.
+
+{% tabs %}
+{% tab title="Typescript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import { TatumSDK, Network, Ethereum, ResponseDto, FungibleTokenBalance } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({ network: Network.ETHEREUM })
+
+const balance: ResponseDto = await tatum.token.getBalance({
+ addresses: ['0x78E851C35326c9296485E9720D85CB3Bd153b428'], // replace with your address
+ })
+
+console.log(balance.data)
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="Javascript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const balance = await tatum.token.getBalance({ addresses: ['0x78E851C35326c9296485E9720D85CB3Bd153b428'], // replace with your address
+ });
+ console.log(balance.data);
+ } catch (error) {
+ console.error("Error fetching balances of fungible tokens:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```
+curl --location --request GET 'https://api.tatum.io/v4/data/balances?chain=ethereum&addresses=0x78E851C35326c9296485E9720D85CB3Bd153b428&tokenTypes=fungible'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+
+
+Expected Response
+
+```json5
+[
+ {
+ chain: 'ethereum-mainnet',
+ tokenAddress: '0xd110bb8a24b100c37af7310416e685af807c1f10',
+ type: 'fungible',
+ lastUpdatedBlockNumber: 8167878,
+ address: '0x78e851c35326c9296485e9720d85cb3bd153b428',
+ balance: '0.0006'
+ },
+ {
+ chain: 'ethereum-mainnet',
+ tokenAddress: '0x1fcdce58959f536621d76f5b7ffb955baa5a672f',
+ type: 'fungible',
+ lastUpdatedBlockNumber: 8348276,
+ address: '0x78e851c35326c9296485e9720d85cb3bd153b428',
+ balance: '1'
+ },
+ {
+ chain: 'ethereum-mainnet',
+ tokenAddress: '0x558ec3152e2eb2174905cd19aea4e34a23de9ad6',
+ type: 'fungible',
+ lastUpdatedBlockNumber: 12136720,
+ address: '0x78e851c35326c9296485e9720d85cb3bd153b428',
+ balance: '201.752'
+ }
+]
+```
+
+
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface AddressBalanceDetails {
+ /**
+ * List of addresses to check.
+ */
+ addresses: string[]
+ /**
+ * Optional page size. If not specified, the default page size is used, which is 10.
+ */
+ pageSize?: number
+ /**
+ * Optional page number. If not specified, the first page is returned.
+ */
+ page?: number
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response
+ */
+ data: T
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+
+interface FungibleTokenBalance {
+ /**
+ * Blockchain network
+ */
+ chain: string
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+ /**
+ * Token type, default 'fungible' (ERC-20).
+ */
+ type: 'fungible'
+
+ /**
+ * Block number of the last balance update.
+ */
+ lastUpdatedBlockNumber: number
+
+ /**
+ * Address
+ */
+ address: string
+
+ /**
+ * Balance of the address.
+ */
+ balance: string
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------- |
+| Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai
| Multiple addresses per 1 invocation |
+
diff --git a/docs/fungible-tokens/get-metadata-of-a-fungible-token.md b/docs/fungible-tokens/get-metadata-of-a-fungible-token.md
new file mode 100644
index 0000000..301314e
--- /dev/null
+++ b/docs/fungible-tokens/get-metadata-of-a-fungible-token.md
@@ -0,0 +1,141 @@
+# Get metadata of a fungible token
+
+### Overview
+
+Fungible tokens can carry associated metadata, which is a set of data that provides information about the token's properties. Although each token is indistinguishable in value, metadata can specify attributes such as the token's name, symbol, or total supply. In the realm of cryptocurrencies, metadata is often used to create a clearer understanding of the token's purpose or functionality. For instance, a utility token's metadata might detail the specific service or access it provides within its platform. Similarly, a governance token's metadata could illustrate the voting rights or privileges it conveys in a Decentralised Autonomous Organisation (DAO). Thus, metadata provides essential context, enhancing the fungible tokens' usability in diverse scenarios.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/BaGvOoe" %}
+
+### How to show the metadata of a fungible token on the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get the token metadata.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+// yarn add @tatumio/tatum
+import { TatumSDK, Network, Ethereum, ResponseDto, TokenMetadata } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init<Ethereum>({network: Network.ETHEREUM})
+
+const response: ResponseDto<TokenMetadata> = await tatum.token.getTokenMetadata({
+ tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+ })
+
+console.log(response.data)
+
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const result = await tatum.token.getTokenMetadata({
+ tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+ })
+
+ console.log(result.data);
+ } catch (error) {
+ console.error("Error fetching token metadata:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request GET 'https://api.tatum.io/v4/data/tokens?tokenAddress=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&chain=ethereum'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+
+
+Expected Response
+
+```json5
+{
+ "symbol":"USDC",
+ "name":"USD Coin",
+ "supply":"26667389920178985",
+ "decimals":6,
+ "tokenType":"fungible",
+ "cap":"undefined"
+}
+```
+
+
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface TokenAddress {
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response
+ */
+ data: T
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+
+interface TokenMetadata {
+ /**
+ * Symbol of the fungible token.
+ */
+ symbol: string
+ /**
+ * Full name of the fungible token
+ */
+ name: string
+ /**
+ * Total supply of the fungible token.
+ */
+ supply: string
+ /**
+ * Number of decimal places for the fungible token.
+ */
+ decimals: number
+ /**
+ * Type of the token - fungible
+ */
+ tokenType: string
+ /**
+ * Maximum supply cap of the fungible token.
+ */
+ cap: string
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai
|
diff --git a/docs/fungible-tokens/show-fungible-token-history-of-a-wallet.md b/docs/fungible-tokens/show-fungible-token-history-of-a-wallet.md
new file mode 100644
index 0000000..73152ed
--- /dev/null
+++ b/docs/fungible-tokens/show-fungible-token-history-of-a-wallet.md
@@ -0,0 +1,198 @@
+# Show fungible token history of a wallet
+
+### Overview
+
+Fungible token transfers are critical in blockchain networks. They are used as a means of value exchange in cryptocurrency systems like Bitcoin and Ethereum. Beyond just transactions, they're also transferred into smart contracts in DeFi spaces for participation in liquidity pools or lending protocols. In Decentralised Autonomous Organisations (DAOs), governance tokens, a type of fungible token, are transferred to represent voting rights, enabling holders to have a say in network decisions. The versatility of fungible tokens and their transferability underscores the profound utility they bring to the blockchain ecosystem.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/oNQJMPG" %}
+
+### How to show the fungible token history of a specific wallet on the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get a transaction history of the wallet.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import { TatumSDK, Network, Ethereum, ResponseDto, Transaction } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const txs: ResponseDto = await tatum.token.getAllFungibleTransactions({
+ addresses: ['0x78E851C35326c9296485E9720D85CB3Bd153b428'], // replace with your address
+ })
+
+console.log(txs.data)
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const txs = await tatum.token.getAllFungibleTransactions({
+ addresses: ['0x78E851C35326c9296485E9720D85CB3Bd153b428'], // replace with your address
+ })
+ console.log(txs.data);
+ } catch (error) {
+ console.error("Error fetching wallet history:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request GET 'https://api.tatum.io/v4/data/transactions?addresses=0x78E851C35326c9296485E9720D85CB3Bd153b428&chain=ethereum&transactionTypes=fungible'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+
+
+Expected Response
+
+```json5
+[
+ {
+ "chain":"ethereum-mainnet",
+ "blockNumber":17463011,
+ "hash":"0x3509d471bf8362f4bffcfec8d27b0d1d6af3d3520dbd72f2aad61cfb8e22417f",
+ "transactionType":"fungible",
+ "transactionIndex":60,
+ "tokenAddress":"0xdac17f958d2ee523a2206206994597c13d831ec7",
+ "amount":"3900",
+ "timestamp":1686561155000,
+ "address":"0x78e851c35326c9296485e9720d85cb3bd153b428",
+ "counterAddress":"0x54157126f10ed5019ab2785cd8f1ced207d10346",
+ "transactionSubtype":"incoming"
+ }
+]
+```
+
+
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface GetAllFungibleTransactionsQuery {
+ /**
+ * Token contract address
+ */
+ tokenAddress?: string
+ /**
+ * Addresses to fetch. Up to 10 addresses as a comma separated string.
+ */
+ addresses: string[]
+ /**
+ * Optional transaction type. If not specified, both incoming and outgoing transactions are returned.
+ */
+ transactionTypes?: TransactionType[]
+ /**
+ * Optional from block. If not specified, all transactions are returned from the beginning of the blockchain.
+ */
+ blockFrom?: number
+ /**
+ * Optional to block. If not specified, all transactions are returned up till now.
+ */
+ blockTo?: number
+ /**
+ * Optional page size. If not specified, the default page size is used, which is 10.
+ */
+ pageSize?: number
+ /**
+ * Optional page number. If not specified, the first page is returned.
+ */
+ page?: number
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response
+ */
+ data: T
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+
+interface Transaction {
+ /**
+ * Blockchain network
+ */
+ chain: string
+ /**
+ * Block number
+ */
+ blockNumber: number
+ /**
+ * Transaction hash
+ */
+ hash: string
+ /**
+ * Transaction type
+ */
+ transactionType: 'fungible' | 'nft' | 'multitoken' | 'native' | 'internal'
+ /**
+ * Transaction sub type
+ */
+ transactionSubtype: 'incoming' | 'outgoing' | 'zero-transfer'
+ /**
+ * Index of the transaction in the block
+ */
+ transactionIndex: number
+ /**
+ * Address of the token collection
+ */
+ tokenAddress?: string
+ /**
+ * The ID of the token involved in the transaction (optional).
+ */
+ tokenId?: string
+ /**
+ * Amount transferred. For outgoing transactions, it's a negative number. For zero-transfer transactions, it's always 0. For incoming transactions, it's a positive number.
+ */
+ amount: string
+ /**
+ * Transaction timestamp - UTC millis
+ */
+ timestamp: number
+ /**
+ * Address, on which transaction occurred. This is receiver address for incoming transactions and sender address for outgoing transactions.
+ */
+ address: string
+ /**
+ * Counter address of the transaction. This is sender address for incoming transactions on `address` and receiver address for outgoing transactions on `address`.
+ */
+ counterAddress?: string
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------- |
+| Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai
| Multiple addresses per 1 invocation |
diff --git a/docs/nfts/README.md b/docs/nfts/README.md
new file mode 100644
index 0000000..159e389
--- /dev/null
+++ b/docs/nfts/README.md
@@ -0,0 +1,23 @@
+# ๐ต NFTs
+
+A non-fungible token (NFT) is a unique digital asset that represents ownership of a one-of-a-kind item or piece of content, such as digital art, virtual real estate, or collectibles. Unlike fungible tokens, NFTs are not interchangeable, and each NFT has a distinct value based on its rarity, provenance, and demand for that specific token.
+
+## Video Guide on how to use NFT Submodule
+
+In this video guide we have demonstrated how you can use the Check Owner of an NFT function of this NFT Submodule to create a NFT gating app. This video is also helpful to get you started on using this submodule.
+
+{% embed url="https://youtu.be/byTVqO3eefE" %}
+Building an NFT Gated Website.
+{% endembed %}
+
+## Use cases of NFT's
+
+NFTs provide various benefits and use cases for both businesses and individuals:
+
+1. **Digital Art and Collectibles**: NFTs have become popular for digital artists and creators, as they can mint unique digital art pieces as NFTs, enabling them to prove ownership, protect their intellectual property, and monetise their creations. Collectors can buy, trade, and showcase their NFT collections, deriving value from their rarity and uniqueness.
+2. **Gaming and Virtual Items**: NFTs have transformed the gaming industry, allowing players to own in-game assets such as characters, items, and virtual real estate. These NFT-based assets can be traded, sold, or transferred across different platforms, creating a new economy within the gaming ecosystem.
+3. **Tokenized Physical Assets**: NFTs enable businesses to tokenize real-world assets like real estate, luxury goods, or even fine art. This tokenization process facilitates fractional ownership, making it possible for a broader audience to invest in and trade valuable assets that were previously less accessible.
+4. **Proof of Authenticity**: NFTs can serve as digital certificates of authenticity for various items, ensuring their provenance and verifying their scarcity. This can be beneficial for businesses dealing with high-value products, such as luxury brands or art dealers, as it can help prevent counterfeiting and create trust in the market.
+5. **Royalties and Secondary Sales**: NFTs can be programmed to generate royalties for creators every time their work is resold in the secondary market. This provides a new revenue stream for artists and creators, empowering them to capture more value from their work.
+
+For common people, NFTs present a new way to participate in the digital economy, enabling them to own, trade, and invest in unique digital assets that can appreciate in value over time. Additionally, NFTs offer a means to support their favorite artists, creators, and brands in a direct and meaningful way.
diff --git a/docs/nfts/check-if-the-wallet-owns-a-specific-nft.md b/docs/nfts/check-if-the-wallet-owns-a-specific-nft.md
new file mode 100644
index 0000000..9be94f6
--- /dev/null
+++ b/docs/nfts/check-if-the-wallet-owns-a-specific-nft.md
@@ -0,0 +1,132 @@
+---
+description: >-
+ This function checks if a wallet own's any or a specific nft from a
+ collection, you can pass collection address, wallet address & tokenId as an
+ option parameter.
+---
+
+# Check if the wallet owns a specific NFT
+
+{% embed url="https://codepen.io/tatum-devrel/pen/bGQOjoQ" %}
+Try this feature
+{% endembed %}
+
+### Overview
+
+In the rapidly growing world of non-fungible tokens (NFTs), verifying the ownership of a particular NFT is crucial for creators, collectors, and traders alike. This guide introduces you to the operation of checking if a wallet owns a specific NFT, providing an efficient way to confirm the possession of unique digital assets. By leveraging this functionality, you can ensure the accuracy and authenticity of your NFT holdings, make well-informed decisions about buying, selling, or holding NFTs, and navigate the dynamic NFT landscape with greater confidence. Ultimately, this operation empowers you to manage your digital assets more effectively, fostering transparency and trust in your NFT transactions.
+
+### How to get the owner of the NFT on the Ethereum network
+
+Use the TatumSDK (`@tatumcom/js`) to check, if the wallet is the owner.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init<Ethereum>({network: Network.ETHEREUM})
+
+const isOwner: boolean = await tatum.nft.checkNftOwner({
+ tokenAddress: '0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d', // replace with your collection
+ tokenId: '1',
+ owner: '0x46efbaedc92067e6d60e84ed6395099723252496' // owner wallet
+})
+
+console.log(isOwner)
+
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const isOwner = await tatum.nft.checkNftOwner({
+ tokenAddress: "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d", // replace with your collection
+ tokenId: "1",
+ owner: "0x46efbaedc92067e6d60e84ed6395099723252496" // owner wallet
+ });
+ console.log(isOwner);
+ } catch (error) {
+ console.error("Error checking NFT owner:", error);
+ }
+})();
+
+
+// Expected outcome
+// true
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request GET 'https://api.tatum.io/v4/data/owners/address?tokenAddress=0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d&tokenId=1&chain=ethereum&address=0x46efbaedc92067e6d60e84ed6395099723252496'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+###
+
+
+
+Expected Response
+
+```json5
+true
+```
+
+
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface GetTokenOwner {
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+ /**
+ * Owner address of the NFT token
+ */
+ owner: string
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response - true or false result
+ */
+ data: boolean
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
|---|
Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai | NFTs (BAYC,...)
ERC-1155 Tokens |
+
diff --git a/docs/nfts/create-multitoken-nft-collection.md b/docs/nfts/create-multitoken-nft-collection.md
new file mode 100644
index 0000000..36a001d
--- /dev/null
+++ b/docs/nfts/create-multitoken-nft-collection.md
@@ -0,0 +1,134 @@
+# Create MultiToken NFT Collection
+
+ERC-1155 is a standard for smart contracts on the Ethereum blockchain, which encompasses the functionality of both ERC-20 (fungible tokens, like cryptocurrencies) and ERC-721 (non-fungible tokens, or NFTs) within a single smart contract. This makes it a MultiToken standard.
+
+In the ERC-1155 standard, each token is identified by an ID. What makes this different from ERC-721 (where each token also has a unique ID) is that tokens of the same ID in ERC-1155 are interchangeable, just like ERC-20 tokens. This allows for both fungible and non-fungible tokens to be represented within a single contract.
+
+### Use Cases for ERC-1155 MultiToken Collections
+
+1. **Video Games**: ERC-1155 tokens can represent a wide variety of assets within a game, such as fungible resources (like in-game currency or consumable items) and non-fungible unique items (like a special character or a limited edition weapon). This can all be done within a single, smart contract.
+2. **DeFi Platforms**: A single ERC-1155 contract can manage a variety of tokens, such as governance tokens (fungible) and insurance contracts or loan receipts (non-fungible).
+3. **Art and Collectibles**: Just like with ERC-721, artists can mint their artworks as NFTs with ERC-1155. However, with ERC-1155 they can also issue fungible tokens, such as prints or copies, alongside the unique piece.
+4. **Real World Assets**: ERC-1155 tokens can represent ownership in real world assets, such as real estate or commodities. The fungible tokens can represent a divisible interest in an asset, while non-fungible tokens can represent unique assets.
+
+By using the Tatum SDK to create an ERC-1155 MultiToken collection, you're able to manage a complex economy of both fungible and non-fungible tokens with ease. Whether you're developing an intricate in-game economy or creating a platform with diverse types of assets, ERC-1155 offers a versatile solution for digital ownership and trade.
+
+### How to show create MultiToken NFT Collection (ERC-1155 type) on the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get a transaction history of the wallet.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, ResponseDto} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const tx: ResponseDto<{txId: string}> = await tatum.nft.createMultiTokenNftCollection({
+ owner: '0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d', // replace with your address
+})
+
+console.log(tx.data.txId)
+// 0x8e564406701caab6258501c794f5c1eece380f673be99b561d626c3d8d81b202
+
+// you can get created collection address using this RPC call
+const collectionAddress = await tatum.rpc.getContractAddress(tx.data.txId)
+console.log(collectionAddress)
+// 0x876977006988ce590e219f576077459a49c7318a
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const txs = await tatum.nft.createMultiTokenNftCollection({
+ owner: '0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d', // replace with your address
+ });
+ console.log(txs.data.txId);
+ // 0x8e564406701caab6258501c794f5c1eece380f673be99b561d626c3d8d81b202
+
+ const collectionAddress = await tatum.rpc.getContractAddress(tx.data.txId);
+ console.log(collectionAddress);
+ // 0x876977006988ce590e219f576077459a49c7318a
+ } catch (error) {
+ console.error("Error creating NFT collection:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request POST 'https://api.tatum.io/v4/contract/deploy' \
+--header 'Content-Type: application/json' \
+--data-raw '{
+ "contractType": "multitoken",
+ "chain": "ethereum-sepolia",
+ "owner": "0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d"
+}'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% embed url="https://codepen.io/tatum-devrel/pen/LYXMBpZ" %}
+Try this feature
+{% endembed %}
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+export interface CreateMultiTokenNftCollection {
+ /**
+ * Address of the NFT collection owner
+ */
+ owner: string
+ /**
+ * Address of the NFT collection minter, this is optional and defaults to the owner address
+ */
+ minter?: string
+ /**
+ * Optional base URI, which will be prepended to the token URI. If not specified, the token should be minted with the URI
+ */
+ baseURI?: string
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto<{txId: string}> {
+ /**
+ * Actual payload of the response
+ */
+ data: {txId: string}
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
|---|
Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai | NFTs (BAYC,...)
ERC-1155 Tokens |
+
diff --git a/docs/nfts/create-nft-collection.md b/docs/nfts/create-nft-collection.md
new file mode 100644
index 0000000..e4980f4
--- /dev/null
+++ b/docs/nfts/create-nft-collection.md
@@ -0,0 +1,149 @@
+# Create NFT Collection
+
+An NFT, or non-fungible token, is a type of cryptocurrency that represents a unique item or asset. Unlike regular cryptocurrencies such as Bitcoin or Ether, NFTs aren't interchangeable with other tokens of the same type but stand as unique tokens with their own specific value. They leverage blockchain technology to establish provenance and ownership.
+
+An NFT collection is a group of NFTs, typically bound together by a common theme or brand. Each individual NFT within the collection is unique, but they are all part of the broader collection. Think of it like a collection of paintings from the same artist or a series of collectible toys.
+
+### Use Cases for NFT Collections
+
+1. **Art**: Artists can mint their artworks as NFTs and sell them directly to collectors. Each NFT represents a unique piece of art or a limited edition series.
+2. **Collectibles**: Virtual collectibles, such as CryptoPunks or NBA Top Shots, are often grouped into collections. Each unique item in the collection is an NFT.
+3. **Virtual Real Estate and Goods**: Platforms like Decentraland allow users to own and trade virtual land and assets as NFTs.
+4. **Music and Entertainment**: Musicians can mint their albums or songs as NFTs, providing a new way to monetize their work and connect with fans. Movies or show clips can also be tokenized as collectible NFTs.
+5. **Identity and Certification**: NFTs can be used to represent ownership or the achievement of something, such as completing a course or owning a specific domain name.
+
+By creating an NFT collection using the Tatum SDK, you can easily mint, manage, and distribute NFTs on the blockchain. Whether you're an artist launching a new series of artwork, a game developer creating unique in-game items, or a brand creating digital collectibles, the ability to create an NFT collection offers exciting new possibilities for digital ownership and commerce.
+
+### How to create NFT Collection (ERC-721 type) on the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to create the NFT collection.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, ResponseDto} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const tx: ResponseDto<{txId: string}> = await tatum.nft.createNftCollection({
+ name: 'My NFT Collection',
+ symbol: 'MyNFT',
+ owner: '0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d', // replace with your address
+})
+
+console.log(tx.data.txId)
+// 0x8e564406701caab6258501c794f5c1eece380f673be99b561d626c3d8d81b202
+
+// you can get created collection address using this RPC call
+const collectionAddress = await tatum.rpc.getContractAddress(tx.data.txId)
+console.log(collectionAddress)
+// 0x876977006988ce590e219f576077459a49c7318a
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const txs = await tatum.nft.createNftCollection({
+ name: 'My NFT Collection,
+ symbol: 'MyNFT'
+ owner: '0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d', // replace with your address
+ });
+ console.log(txs.data.txId);
+ // 0x8e564406701caab6258501c794f5c1eece380f673be99b561d626c3d8d81b202
+
+ const collectionAddress = await tatum.rpc.getContractAddress(tx.data.txId);
+ console.log(collectionAddress);
+ // 0x876977006988ce590e219f576077459a49c7318a
+ } catch (error) {
+ console.error("Error creating NFT collection:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request POST 'https://api.tatum.io/v4/contract/deploy' \
+--header 'Content-Type: application/json' \
+--data-raw '{
+ "contractType": "nft",
+ "chain": "ethereum-sepolia",
+ "name": "My NFT Collection",
+ "symbol": "MyNFT",
+ "owner": "0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d"
+}'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% embed url="https://codepen.io/tatum-devrel/pen/zYMyagO" %}
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+export interface CreateNftCollection {
+ /**
+ * Name of the NFT collection, e.g. Bored Ape Yacht Club
+ */
+ name: string
+ /**
+ * Symbol of the NFT collection, e.g. BAYC
+ */
+ symbol: string
+ /**
+ * Address of the NFT collection owner
+ */
+ owner: string
+ /**
+ * Address of the NFT collection minter, this is optional and defaults to the owner address
+ */
+ minter?: string
+ /**
+ * Optional base URI, which will be prepended to the token URI. If not specified, the token should be minted with the URI
+ */
+ baseURI?: string
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto<{txId: string}> {
+ /**
+ * Actual payload of the response
+ */
+ data: {txId: string}
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
|---|
Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai | NFTs (BAYC,...)
ERC-1155 Tokens |
+
+### Limitations
+
diff --git a/docs/nfts/get-all-nfts-in-the-nft-collection.md b/docs/nfts/get-all-nfts-in-the-nft-collection.md
new file mode 100644
index 0000000..48d52b7
--- /dev/null
+++ b/docs/nfts/get-all-nfts-in-the-nft-collection.md
@@ -0,0 +1,168 @@
+# Get all NFTs in the NFT collection
+
+As the non-fungible token (NFT) market continues to flourish, creators, collectors, and traders need efficient ways to manage and explore their digital collections. This guide introduces you to the operation of retrieving all NFTs in a specific collection, providing a comprehensive view of the unique digital assets grouped together. By leveraging this functionality, you can easily navigate and analyze your NFT collection, gain insights into the themes and trends within your portfolio, and make informed decisions about buying, selling, or holding specific NFTs. Ultimately, this operation enables you to better understand your digital assets, streamlines your NFT management, and empowers you to engage with the NFT market more effectively.
+
+### How to get NFTs of a collection in the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get all NFTs of the collection.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, ResponseDto, NftTokenDetail} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const nfts: ResponseDto = await tatum.nft.getNftsInCollection({
+ collectionAddress: '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D', // replace with your collection
+})
+
+console.log(nfts.data)
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const nfts = await tatum.nft.getNftsInCollection({
+ collectionAddress: '0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D', // replace with your collection
+ });
+ console.log(nfts.data);
+ } catch (error) {
+ console.error("Error fetching NFT collection:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request GET 'https://api.tatum.io/v4/data/collections?collectionAddresses=0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D&chain=ethereum'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% embed url="https://codepen.io/tatum-devrel/pen/eYQbKxX" %}
+
+
+
+
+
+Expected Response
+
+```json5
+[
+ {
+ "address": "0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d",
+ "balance": "2",
+ "chain": "ethereum-mainnet",
+ "lastUpdatedBlockNumber": 14086122,
+ "metadata": {
+ "description": "# ***\"Sometimes I swear I can see a glimmer of the Sun through all the layers of chaos. It's probably just wishful thinking. There's a lot of that here.\" โ Renn Dialos, Alexandria Research Node 557***\n### **1 / 71492 Jupiter DAO Tokens**\n\nThis token represents proportional ownership over Jupiter. Together with other Jupiter DAO Token holders, its owner is able to actively build and govern the planet into its own unique environment.\n\n*Jupiter represents 10.4% of the total voting power for MetaHero Universe's United Planets DAO.*\n\n*[ Token Design by: TheVirtunaut, Odious, Raw & Rendered | Joey Camacho ]*",
+ "external_url": "https://punkscomic.com",
+ "image": "ipfs://QmS21WhH94jBnYompXHD1SxS6Gw2bY8E81sTYRktWrYa7a/JUPITER.mp4",
+ "name": "MetaHero Universe: Jupiter DAO Token"
+ },
+ "metadataURI": "ipfs://QmR9PokA9rnKKUF1uLtZyHYEhExqQU1Z7t8AbovMBxND4U/5",
+ "tokenAddress": "0x7deb7bce4d360ebe68278dee6054b882aa62d19c",
+ "tokenId": "5",
+ "type": "multitoken"
+ }
+]
+```
+
+
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface GetCollection {
+ /**
+ * Collection contract address
+ */
+ collectionAddress: string
+ /**
+ * Optional flag to exclude metadata from the response. In this case, only token IDs are returned. Defaults to false.
+ */
+ excludeMetadata?: boolean
+ /**
+ * Optional page size. If not specified, the default page size is used, which is 10.
+ */
+ pageSize?: number
+ /**
+ * Optional page number. If not specified, the first page is returned.
+ */
+ page?: number
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response
+ */
+ data: T
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+
+interface NftTokenDetail {
+ /**
+ * Blockchain network
+ */
+ chain: string
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+ /**
+ * Token type. Either 'nft' (ERC-721) or 'multitoken' (ERC-1155)
+ */
+ tokenType: 'nft' | 'multitoken'
+ /**
+ * Token URI
+ */
+ metadataURI: string
+ /**
+ * Token metadata
+ */
+ metadata?: {
+ name: string
+ description: string
+ image: string
+ [metadataKey: string]: unknown
+ }
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
|---|
Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai | Multiple addresses per 1 invocation
NFTs (BAYC,...)
ERC-1155 Tokens |
diff --git a/docs/nfts/get-all-nfts-the-wallet-holds.md b/docs/nfts/get-all-nfts-the-wallet-holds.md
new file mode 100644
index 0000000..dc9e9a0
--- /dev/null
+++ b/docs/nfts/get-all-nfts-the-wallet-holds.md
@@ -0,0 +1,178 @@
+---
+description: >-
+ This function helps you to fetch all the NFT's a wallet holds, all you have to
+ do is pass the address to the function parameter and chain while initialising
+ the sdk.
+---
+
+# Get all NFTs the wallet holds
+
+The world of non-fungible tokens (NFTs) has witnessed exponential growth, attracting artists, collectors, and investors alike. As users accumulate various NFTs across multiple blockchain networks, it becomes crucial to manage and track their digital collections. This guide introduces you to the operation of obtaining all NFTs associated with a particular address, offering you a comprehensive snapshot of your NFT holdings. By leveraging this functionality, you can effectively monitor your NFT collection, verify ownership, and assess the value of your digital assets. Ultimately, this operation empowers you to take full control of your unique digital assets and manage them with greater ease and efficiency.
+
+### How to get NFTs on a wallet in the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get a balance of the wallet.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, ResponseDto, NftAddressBalance} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const balance: ResponseDto = await tatum.nft.getBalance({
+ addresses: ['0x727EA45B2EB6abb2badD3dC7106d146E0Dc0450d'], // replace with your address
+})
+
+console.log(balance.data)
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const balance = await tatum.nft.getBalance({
+ addresses: ['0x727EA45B2EB6abb2badD3dC7106d146E0Dc0450d'], // replace with your address
+ });
+ console.log(balance.data);
+ } catch (error) {
+ console.error("Error fetching NFT balance:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request GET 'https://api.tatum.io/v4/data/balances?chain=ethereum&addresses=0x727EA45B2EB6abb2badD3dC7106d146E0Dc0450d'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% embed url="https://codepen.io/tatum-devrel/pen/oNQJyJb" %}
+
+
+
+Expected Response
+
+```json5
+[
+ {
+ "address": "0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d",
+ "balance": "2
+ ",
+ "chain": "ethereum-mainnet",
+ "lastUpdatedBlockNumber": 14086122,
+ "metadata": {
+ "description": "# ***\"Sometimes I swear I can see .... | Joey Camacho ]*",
+ "external_url": "https://punkscomic.com",
+ "image": "ipfs://QmS21WhH94jBnYompXHD1SxS6Gw2bY8E81sTYRktWrYa7a/JUPITER.mp4",
+ "name": "MetaHero Universe: Jupiter DAO Token"
+ },
+ "metadataURI": "ipfs://QmR9PokA9rnKKUF1uLtZyHYEhExqQU1Z7t8AbovMBxND4U/5",
+ "tokenAddress": "0x7deb7bce4d360ebe68278dee6054b882aa62d19c",
+ "tokenId": "5",
+ "type": "multitoken"
+ }
+]
+```
+
+
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface AddressBalanceDetails {
+ /**
+ * List of addresses to check.
+ */
+ addresses: string[]
+ /**
+ * Optional page size. If not specified, the default page size is used, which is 10.
+ */
+ pageSize?: number
+ /**
+ * Optional page number. If not specified, the first page is returned.
+ */
+ page?: number
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response
+ */
+ data: T
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+
+interface NftAddressBalance {
+ /**
+ * Balance of the address.
+ */
+ balance: string
+ /**
+ * Blockchain network
+ */
+ chain: string
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+ /**
+ * Token type. Either 'nft' (ERC-721) or 'multitoken' (ERC-1155)
+ */
+ tokenType: 'nft' | 'multitoken'
+ /**
+ * Token URI
+ */
+ metadataURI: string
+ /**
+ * Token metadata
+ */
+ metadata?: {
+ name: string
+ description: string
+ image: string
+ [metadataKey: string]: unknown
+ }
+ /**
+ * Block number of the last balance update.
+ */
+ lastUpdatedBlock: number
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
|---|
Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai | Multiple addresses per 1 invocation
NFTs (BAYC,...)
ERC-1155 Tokens |
diff --git a/docs/nfts/get-the-metadata-of-a-specific-nft.md b/docs/nfts/get-the-metadata-of-a-specific-nft.md
new file mode 100644
index 0000000..f8811cd
--- /dev/null
+++ b/docs/nfts/get-the-metadata-of-a-specific-nft.md
@@ -0,0 +1,119 @@
+# Get the metadata of a specific NFT
+
+As non-fungible tokens (NFTs) gain popularity in the digital asset space, it becomes increasingly important for creators, collectors, and traders to have access to detailed information about individual NFTs. This guide introduces you to the operation of retrieving the metadata of a specific NFT, providing valuable insights into the unique properties, characteristics, and history of the digital asset. By leveraging this functionality, you can better understand the provenance, rarity, and artistic attributes of the NFT, make well-informed decisions about buying, selling, or holding it, and navigate the dynamic NFT market with greater confidence. Ultimately, this operation allows you to manage your digital assets more effectively and fosters a deeper appreciation for the unique qualities of each NFT.
+
+### How to get the metada of the NFT on the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get the metadata of the specific NFT.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, ResponseDto, NftTokenDetail} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const metadata: ResponseDto = await tatum.nft.getNftMetadata({
+ tokenAddress: '0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d', // replace with your collection
+ tokenId: '1'
+})
+
+console.log(metadata.data)
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const metadata = await tatum.nft.getNftMetadata({
+ tokenAddress: "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d", // replace with your collection
+ tokenId: "1"
+ });
+ console.log(metadata.data);
+ } catch (error) {
+ console.error("Error getting NFT metadata:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request GET 'https://api.tatum.io/v4/data/metadata?chain=ethereum&tokenAddress=0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d&tokenIds=1'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% embed url="https://codepen.io/tatum-devrel/pen/XWyoBYd" %}
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface GetNftMetadata {
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface NftTokenDetail {
+ /**
+ * Blockchain network
+ */
+ chain: string
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+ /**
+ * Token type. Either 'nft' (ERC-721) or 'multitoken' (ERC-1155)
+ */
+ tokenType: 'nft' | 'multitoken'
+ /**
+ * Token URI
+ */
+ metadataURI: string
+ /**
+ * Token metadata
+ */
+ metadata?: {
+ name: string
+ description: string
+ image: string
+ [metadataKey: string]: unknown
+ }
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
|---|
Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai | NFTs (BAYC,...)
ERC-1155 Tokens |
+
diff --git a/docs/nfts/retrieve-the-owner-of-the-nft.md b/docs/nfts/retrieve-the-owner-of-the-nft.md
new file mode 100644
index 0000000..d8dc4eb
--- /dev/null
+++ b/docs/nfts/retrieve-the-owner-of-the-nft.md
@@ -0,0 +1,122 @@
+# Retrieve the owner of the NFT
+
+In the rapidly evolving world of non-fungible tokens (NFTs), it is essential for creators, collectors, and traders to have the ability to verify the ownership of individual NFTs. This guide introduces you to the operation of retrieving the owner of a specific NFT, providing you with the necessary information to confirm the current holder of the unique digital asset. By leveraging this functionality, you can ensure the authenticity and provenance of the NFT, make informed decisions about buying, selling, or holding it, and navigate the dynamic NFT market with confidence. Ultimately, this operation enables you to manage your digital assets more effectively and maintain the integrity of your NFT transactions.
+
+### How to get the owner of the NFT on the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get an owner of the NFT.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, ResponseDto, NftTransaction} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const owner: ResponseDto = await tatum.nft.getNftOwner({
+ tokenAddress: '0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d', // replace with your collection
+ tokenId: '1'
+})
+
+console.log(owner.data)
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const txs = await tatum.nft.getNftOwner({
+ tokenAddress: "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d", // replace with your collection
+ tokenId: "1"
+ });
+ console.log(txs.data);
+ } catch (error) {
+ console.error("Error fetching NFT owner:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request GET 'https://api.tatum.io/v4/data/owners?tokenAddress=0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d&tokenId=1&chain=ethereum'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% embed url="https://codepen.io/tatum-devrel/pen/rNQorxB" %}
+
+
+
+Expected Response
+
+```json5
+[
+ "0x46efbaedc92067e6d60e84ed6395099723252496"
+]
+```
+
+
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface GetTokenOwner {
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+ /**
+ * Optional page size. If not specified, the default page size is used, which is 10.
+ */
+ pageSize?: number
+ /**
+ * Optional page number. If not specified, the first page is returned.
+ */
+ page?: number
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response - list of the owner address
+ */
+ data: string[]
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
|---|
Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai | NFTs (BAYC,...)
ERC-1155 Tokens |
+
diff --git a/docs/nfts/show-the-nft-history-of-a-wallet.md b/docs/nfts/show-the-nft-history-of-a-wallet.md
new file mode 100644
index 0000000..d36864e
--- /dev/null
+++ b/docs/nfts/show-the-nft-history-of-a-wallet.md
@@ -0,0 +1,196 @@
+# Show the NFT history of a wallet
+
+As non-fungible tokens (NFTs) gain traction in the world of digital assets, it becomes increasingly essential for users to manage and monitor their NFT-related transactions across various blockchain networks. This guide introduces you to obtaining all NFT transactions for a specific wallet, offering a comprehensive view of your NFT wallet history. By leveraging this functionality, you can effectively track the acquisition, transfer, and sale of NFTs associated with your wallet, analyze your trading patterns, and maintain accurate records for tax or accounting purposes. Ultimately, this operation empowers you to take full control of your unique digital assets and navigate the ever-evolving NFT landscape with greater ease and efficiency.
+
+### How to show the NFT history of a specific wallet on the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get a transaction history of the wallet.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, ResponseDto, NftTransaction} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const txs: ResponseDto = await tatum.nft.getAllNftTransactionsByAddress({
+ addresses: ['0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d'], // replace with your address
+})
+
+console.log(txs.data)
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const txs = await tatum.nft.getAllNftTransactionsByAddress({
+ addresses: ['0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d'], // replace with your address
+ });
+ console.log(txs.data);
+ } catch (error) {
+ console.error("Error fetching wallet history:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request GET 'https://api.tatum.io/v4/data/transactions?addresses=0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d&chain=ethereum'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% embed url="https://codepen.io/tatum-devrel/pen/qBQLKGO?editors=1111" %}
+
+###
+
+
+
+Expected Response
+
+```javascript
+[
+ {
+ "chain": "ethereum-mainnet",
+ "hash": "0x3d5dafbb461ae5b1a485756c345779ed7e0a21ca4d8e2d59fb3453a7c38131b9",
+ "address": "0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d",
+ "blockNumber": 17029923,
+ "transactionIndex": 79,
+ "transactionType": "nft",
+ "transactionSubtype": "outgoing",
+ "amount": "-0.2",
+ "timestamp": 1681278035000,
+ "counterAddress": "0x64ceaaf5df1be80f29f35589f096f0714f458b40"
+ }
+]
+```
+
+
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface GetAllNftTransactionsByAddress {
+ /**
+ * Addresses to get NFT transactions from.
+ */
+ addresses: string[]
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+ /**
+ * Optional transaction type. If not specified, both incoming and outgoing transactions are returned.
+ */
+ transactionType?: 'incoming' | 'outgoing'
+ /**
+ * Optional from block. If not specified, all transactions are returned from the beginning of the blockchain.
+ */
+ fromBlock?: number
+ /**
+ * Optional to block. If not specified, all transactions are returned up till now.
+ */
+ toBlock?: number
+ /**
+ * Optional page size. If not specified, the default page size is used, which is 10.
+ */
+ pageSize?: number
+ /**
+ * Optional page number. If not specified, the first page is returned.
+ */
+ page?: number
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response
+ */
+ data: T
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+
+interface NftTransaction {
+ /**
+ * Blockchain network
+ */
+ chain: string
+ /**
+ * Block number
+ */
+ blockNumber: number
+ /**
+ * Transaction hash
+ */
+ hash: string
+ /**
+ * Transaction type
+ */
+ transactionType: 'incoming' | 'outgoing' | 'zero-transfer'
+ /**
+ * Index of the transaction in the block
+ */
+ transactionIndex: number
+ /**
+ * Address of the token collection
+ */
+ tokenAddress: string
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Amount transferred. For outgoing transactions, it's a negative number. For zero-transfer transactions, it's always 0. For incoming transactions, it's a positive number.
+ */
+ amount: string
+ /**
+ * Transaction timestamp - UTC millis
+ */
+ timestamp: number
+ /**
+ * Address, on which transaction occurred. This is receiver address for incoming transactions and sender address for outgoing transactions.
+ */
+ address: string
+ /**
+ * Counter address of the transaction. This is sender address for incoming transactions on `address` and receiver address for outgoing transactions on `address`.
+ */
+ counterAddress: string
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
|---|
Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai | NFTs (BAYC,...)
ERC-1155 Tokens |
+
diff --git a/docs/nfts/trace-the-history-of-a-specific-nft.md b/docs/nfts/trace-the-history-of-a-specific-nft.md
new file mode 100644
index 0000000..3eedb64
--- /dev/null
+++ b/docs/nfts/trace-the-history-of-a-specific-nft.md
@@ -0,0 +1,207 @@
+# Trace the history of a specific NFT
+
+As the popularity of non-fungible tokens (NFTs) continues to surge, it becomes increasingly important for creators, collectors, and traders to monitor the transaction history of individual NFTs. This guide introduces you to the operation of obtaining all transactions for a specific NFT, providing a detailed overview of its transfer, trading, and ownership history. By leveraging this functionality, you can gain insights into the provenance and value of an NFT, assess its authenticity, and make informed decisions about buying, selling, or holding it. Ultimately, this operation enables you to navigate the dynamic NFT market with confidence and manage your digital assets more effectively.
+
+### How to trace the history of a specific NFT on the Ethereum network
+
+Use the TatumSDK (`@tatumio/tatum`) to get a transaction history of the NFT.
+
+{% tabs %}
+{% tab title="TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, ResponseDto, NftTransaction} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const txs: ResponseDto = await tatum.nft.getAllNftTransactions({
+ tokenId: '14721',
+ tokenAddress: '0xccb9d89e0f77df3618eec9f6bf899be3b5561a89', // replace with your collection
+})
+
+console.log(txs.data)
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// Install with: npm install @tatumio/tatum
+const { TatumSDK, Network } = require("@tatumio/tatum");
+
+(async () => {
+ try {
+ const tatum = await TatumSDK.init({ network: Network.ETHEREUM });
+ const txs = await tatum.nft.getAllNftTransactions({
+ tokenId: '14721',
+ tokenAddress: '0xccb9d89e0f77df3618eec9f6bf899be3b5561a89', // replace with your collection
+ });
+ console.log(txs.data);
+ } catch (error) {
+ console.error("Error fetching wallet balance:", error);
+ }
+})();
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl --location --request GET 'https://api.tatum.io/v4/data/transactions?tokenAddress=0xccb9d89e0f77df3618eec9f6bf899be3b5561a89&tokenId=14721&chain=ethereum'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% embed url="https://codepen.io/tatum-devrel/pen/MWzZXxZ" %}
+
+
+
+Expected Response
+
+[
+ {
+ "chain": "ethereum-mainnet",
+ "hash": "0xbbac7d1a2196c5148958bcf4ef05658f8220ca3f0ce1ff6ae9e87f67b9c940c5",
+ "address": "0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d",
+ "blockNumber": 14568283,
+ "transactionIndex": 34,
+ "transactionType": "nft",
+ "transactionSubtype": "incoming",
+ "amount": "1",
+ "timestamp": 1649733396000,
+ "tokenId": "14721",
+ "tokenAddress": "0xccb9d89e0f77df3618eec9f6bf899be3b5561a89",
+ "counterAddress": "0x0000000000000000000000000000000000000000"
+ },
+ {
+ "chain": "ethereum-mainnet",
+ "hash": "0xbbac7d1a2196c5148958bcf4ef05658f8220ca3f0ce1ff6ae9e87f67b9c940c5",
+ "address": "0x0000000000000000000000000000000000000000",
+ "blockNumber": 14568283,
+ "transactionIndex": 34,
+ "transactionType": "nft",
+ "transactionSubtype": "outgoing",
+ "amount": "-1",
+ "timestamp": 1649733396000,
+ "tokenId": "14721",
+ "tokenAddress": "0xccb9d89e0f77df3618eec9f6bf899be3b5561a89",
+ "counterAddress": "0x727ea45b2eb6abb2badd3dc7106d146e0dc0450d"
+ }
+]
+
+
+
+
+### Request interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface GetAllNftTransactionsQuery {
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Token contract address
+ */
+ tokenAddress: string
+ /**
+ * Optional transaction type. If not specified, both incoming and outgoing transactions are returned.
+ */
+ transactionType?: 'incoming' | 'outgoing'
+ /**
+ * Optional from block. If not specified, all transactions are returned from the beginning of the blockchain.
+ */
+ fromBlock?: number
+ /**
+ * Optional to block. If not specified, all transactions are returned up till now.
+ */
+ toBlock?: number
+ /**
+ * Optional page size. If not specified, the default page size is used, which is 10.
+ */
+ pageSize?: number
+ /**
+ * Optional page number. If not specified, the first page is returned.
+ */
+ page?: number
+}
+```
+{% endcode %}
+
+### Response interface
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response
+ */
+ data: T
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+
+interface NftTransaction {
+ /**
+ * Blockchain network
+ */
+ chain: string
+ /**
+ * Block number
+ */
+ blockNumber: number
+ /**
+ * Transaction hash
+ */
+ hash: string
+ /**
+ * Transaction type
+ */
+ transactionType: 'incoming' | 'outgoing' | 'zero-transfer'
+ /**
+ * Index of the transaction in the block
+ */
+ transactionIndex: number
+ /**
+ * Address of the token collection
+ */
+ tokenAddress: string
+ /**
+ * Token ID
+ */
+ tokenId: string
+ /**
+ * Amount transferred. For outgoing transactions, it's a negative number. For zero-transfer transactions, it's always 0. For incoming transactions, it's a positive number.
+ */
+ amount: string
+ /**
+ * Transaction timestamp - UTC millis
+ */
+ timestamp: number
+ /**
+ * Address, on which transaction occurred. This is receiver address for incoming transactions and sender address for outgoing transactions.
+ */
+ address: string
+ /**
+ * Counter address of the transaction. This is sender address for incoming transactions on `address` and receiver address for outgoing transactions on `address`.
+ */
+ counterAddress: string
+}
+```
+{% endcode %}
+
+### Supported blockchain networks
+
+| Network | Support |
|---|
Ethereum / Ethereum Sepolia / Ethereum Goerli
BNB Smart Chain / BNB Smart Chain Testnet
Celo / Celo Alfajores
Polygon / Polygon Mumbai | NFTs (BAYC,...)
ERC-1155 Tokens |
+
diff --git a/docs/notifications/README.md b/docs/notifications/README.md
new file mode 100644
index 0000000..0c505db
--- /dev/null
+++ b/docs/notifications/README.md
@@ -0,0 +1,19 @@
+---
+description: What is a Notification on a Blockchain?
+---
+
+# ๐ฉ Notifications
+
+A notification on a blockchain is an alert or message sent to users when specific events occur on the blockchain network. These events can include transactions, new blocks, contract executions, or any other actions that can be monitored. Notifications are typically delivered through webhook technology, which sends real-time updates to specified endpoints, such as an application or server.
+
+{% hint style="success" %}
+Using blockchain notifications offers significant benefits compared to reading and parsing blocks manually. Notifications streamline the process by delivering real-time updates on relevant events, reducing resource consumption and improving overall efficiency, while also allowing users to focus on building functionality around these events instead of parsing raw blockchain data.
+{% endhint %}
+
+### Why Should People Use Blockchain Notifications?
+
+1. **Real-time Updates**: Blockchain notifications provide real-time updates on events, enabling users to stay informed about the latest transactions, blocks, or smart contract activities. This real-time monitoring is crucial for applications that depend on the timely processing of transactions or other blockchain events.
+2. **Automate Processes**: Notifications can trigger automated processes in response to specific blockchain events. For example, a user might want to automate the release of digital assets when a certain transaction occurs or trigger a specific function in their application upon the creation of a new block.
+3. **Enhanced Security**: By receiving real-time notifications about transactions, users can monitor their accounts or smart contracts for any suspicious activity. In case of an unauthorized transaction, users can take immediate action to mitigate potential risks or losses.
+4. **Efficient Resource Utilization**: Instead of constantly polling the blockchain for updates, which consumes resources and bandwidth, notifications deliver updates only when relevant events occur. This approach reduces the load on your infrastructure and improves overall efficiency.
+5. **Improved User Experience**: By integrating notifications into your application, you can provide users with timely updates on important events, such as the confirmation of a transaction or the execution of a smart contract. This enhances the user experience by keeping them informed and engaged with your platform.
diff --git a/docs/notifications/notification-types/README.md b/docs/notifications/notification-types/README.md
new file mode 100644
index 0000000..82b13ae
--- /dev/null
+++ b/docs/notifications/notification-types/README.md
@@ -0,0 +1,2 @@
+# Notification types
+
diff --git a/docs/notifications/notification-types/address-event.md b/docs/notifications/notification-types/address-event.md
new file mode 100644
index 0000000..6a4f3b0
--- /dev/null
+++ b/docs/notifications/notification-types/address-event.md
@@ -0,0 +1,144 @@
+---
+description: Unlock the Power of ADDRESS_EVENT Notifications for Real-Time Balance Updates
+---
+
+# Address event
+
+Monitoring blockchain addresses can be a challenging and resource-intensive task, especially when you need to track balance updates across multiple token types and currencies. However, with Tatum's ADDRESS\_EVENT notification type, you can stay up-to-date with real-time balance updates, allowing you to streamline your operations and enhance the user experience.
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.addressEvent({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all ETH transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "ADDRESS_EVENT",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format depends on case whether the address you subscribed on is sending or receiving address.\
+\
+**You subscribed sending address**
+
+In this case you will get two notifications fired in your webhook listener:
+
+1. Related to **`fee`** paid for transaction with defined `"type": "fee"`
+
+```json
+{
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "amount": "-0.000031500000168",
+ "asset": "ETH",
+ "blockNumber": 3553692,
+ "txId": "0xde48b2572176eb3e1c4a2a9abe62c5552f778afcbba1ded8491a2ceb675a6390",
+ "type": "fee",
+ "chain": "ethereum-mainnet",
+ "subscriptionType": "ADDRESS_EVENT"
+}
+```
+
+2. Related to **`transaction`** itself with defined `"type": "native"` or "`fungible"` and etc.
+
+{% code lineNumbers="true" %}
+```json
+{
+ "address": "0xfAF0F447715dEeDF6Dd79c2fd1F7966F0CC647A1",
+ "amount": "0.001",
+ "asset": "ETH",
+ "blockNumber": 3553692,
+ "counterAddress": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "txId": "0xde48b2572176eb3e1c4a2a9abe62c5552f778afcbba1ded8491a2ceb675a6390",
+ "type": "native",
+ "chain": "ethereum-mainnet",
+ "subscriptionType": "ADDRESS_EVENT"
+}
+```
+{% endcode %}
+
+**You subscribed receiving address**
+
+In this case you will get only one single notification fired in your webhook listener:
+
+```json
+{
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "amount": "0.0001",
+ "asset": "ETH",
+ "blockNumber": 3553815,
+ "counterAddress": "0xfAF0F447715dEeDF6Dd79c2fd1F7966F0CC647A1",
+ "txId": "0x24e3c8d20449958b53186feb1844a022b864cba67bbca792330b5ab71035b499",
+ "type": "native",
+ "chain": "ethereum-mainnet",
+ "subscriptionType": "ADDRESS_EVENT"
+}
+```
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Bitcoin | Network.BITCOIN | Network.BITCOIN\_TESTNET |
+| Litecoin | Network.LITECOIN | Network.LITECOIN\_TESTNET |
+| Dogecoin | Network.DOGECOIN | Network.DOGECOIN\_TESTNET |
+| Bitcoin Cash | Network.BITCOIN\_CASH | Network.BITCOIN\_CASH\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLAYTN\_BAOBAB |
+| Solana | Network.SOLANA | Network.SOLANA\_DEVNET |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
+| XRP | Network.XRP | Network.XRP\_TESTNET |
+
+### Why Use ADDRESS\_EVENT Notifications?
+
+The ADDRESS\_EVENT notification type delivers a webhook notification every time there is a balance update on a monitored address. This comprehensive notification system covers incoming and outgoing transactions for native currencies, as well as popular token standards like ERC-20, ERC-721, and ERC-1155. Moreover, it even tracks internal smart contract native transfers, ensuring a seamless monitoring experience across various blockchain activities.
+
+Here are some key benefits of using ADDRESS\_EVENT notifications:
+
+#### Real-time Monitoring
+
+Stay informed about balance changes as they happen. ADDRESS\_EVENT notifications provide real-time updates, enabling you to react promptly to important events and ensuring that your application or platform always has the latest information.
+
+#### Simplified Tracking
+
+With support for native currencies, as well as popular token standards like ERC-20, ERC-721, and ERC-1155, ADDRESS\_EVENT notifications simplify the process of tracking balance changes across multiple token types. This feature allows you to focus on building functionality around these events, rather than spending time and resources on parsing raw blockchain data.
+
+#### Enhanced Security
+
+By receiving real-time notifications about balance changes, you can monitor your accounts or smart contracts for any suspicious activity. In case of unauthorized transactions or potential security risks, you can take immediate action to mitigate potential losses.
+
+#### Improved User Experience
+
+Integrating ADDRESS\_EVENT notifications into your application or platform keeps your users informed about balance updates, enhancing their experience and fostering trust in your service. Timely information empowers users to make informed decisions and interact confidently with your platform.
diff --git a/docs/notifications/notification-types/contract-address-log-event.md b/docs/notifications/notification-types/contract-address-log-event.md
new file mode 100644
index 0000000..a19cf1a
--- /dev/null
+++ b/docs/notifications/notification-types/contract-address-log-event.md
@@ -0,0 +1,91 @@
+---
+description: Unleashing the Power of CONTRACT_ADDRESS_LOG_EVENT Notifications
+---
+
+# Contract Address Log Event
+
+The world of blockchain and smart contracts is evolving at an unprecedented pace. CONTRACT\_ADDRESS\_LOG\_EVENT notifications offer a powerful way to stay informed about specific smart contract events in real-time. By utilizing this feature, you can enhance security, streamline data analysis, improve user experience, and maintain flexibility in your monitoring approach. If you're a developer or business involved in the blockchain space, it's time to harness the power of these webhook notifications to optimize your dApp or service.
+
+
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredContractAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const monitoredEvent = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+
+ const subscription = await tatum.notification.subscribe.contractAddressLogEvent({
+ contractAddress: monitoredContractAddress,
+ event: monitoredEvent,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all monitored event calls on ${monitoredContractAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "CONTRACT_ADDRESS_LOG_EVENT",
+ "attr": {
+ "contractAddress": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "event": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "url": "https://"
+ }
+ }'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "events": [
+ {
+ "txId": "0x7d3dda0430471fe460c07b1ecab35670ef4ce85b",
+ "logIndex": 1,
+ "timestamp": 1620914417,
+ "address": "0x7D3Dda0430471Fe460C07b1ecaB35670eF4ce85b",
+ "topic_0": "0x4e3275a5d28e4f6383a4f74592ac9e2f1d0331bde8f7f25cf47d4b15323a47b8",
+ "topic_1": "0x000000000000000000000000f64e82131be01618487da5142fc9d289cbb60e9d",
+ "topic_2": "0x000000000000000000000000690b9a9e9aa1c9db991c7721a92d351db4fac990",
+ "data": "0x0000000000000000000000000000000000000000000000000000000000000064"
+ }
+ ],
+ "blockNumber": 110827114,
+ "chain": "ethereum-mainnet",
+ "subscriptionType": "CONTRACT_ADDRESS_LOG_EVENT"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
diff --git a/docs/notifications/notification-types/failed-transactions-in-a-block.md b/docs/notifications/notification-types/failed-transactions-in-a-block.md
new file mode 100644
index 0000000..b624a6a
--- /dev/null
+++ b/docs/notifications/notification-types/failed-transactions-in-a-block.md
@@ -0,0 +1,88 @@
+---
+description: Stay Ahead of Failed Transactions with FAILED_TXS_PER_BLOCK Notifications
+---
+
+# Failed transactions in a block
+
+In the fast-paced world of blockchain, keeping track of failed transactions is crucial for maintaining a secure and efficient platform. Tatum's OUTGOING\_FAILED\_TX notification type provides an invaluable tool to help you stay informed about all transactions in a block that fail to be included in a block.
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const subscription = await tatum.notification.subscribe.failedTxsPerBlock({
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all failed transactions`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "FAILED_TX_PER_BLOCK",
+ "attr": {
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "0.001",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "subscriptionType": "FAILED_TXS_PER_BLOCK"
+ "blockNumber": 2913059,
+ "txId": "0x062d236ccc044f68194a04008e98c3823271dc26160a4db9ae9303f9ecfc7bf6",
+ "mempool": false
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| Solana | Network.SOLANA | Network.SOLANA\_DEVNET |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
+
+### Why Use FAILED\_TXS\_PER\_BLOCK Notifications?
+
+FAILED\_TXS\_PER\_BLOCK notifications offer an effective way to monitor failed transactions in real-time. By focusing on transactions that fail to be included in a block, this notification type delivers several key benefits:
+
+#### Real-time Monitoring
+
+Stay informed about failed transactions as they occur. FAILED\_TXS\_PER\_BLOCK notifications provide real-time updates, allowing you to react promptly to important events and ensuring your application or platform always has the latest information.
+
+#### Proactive Problem Solving
+
+FAILED\_TXS\_PER\_BLOCK notifications help you identify and address the reasons behind failed transactions, such as insufficient gas fees, incorrect contract addresses, or network congestion. By proactively resolving these issues, you can minimize disruptions and maintain a smooth-running platform.
+
+\
diff --git a/docs/notifications/notification-types/incoming-internal-transactions.md b/docs/notifications/notification-types/incoming-internal-transactions.md
new file mode 100644
index 0000000..a8790bd
--- /dev/null
+++ b/docs/notifications/notification-types/incoming-internal-transactions.md
@@ -0,0 +1,80 @@
+---
+description: Enhance Your Address Monitoring with INCOMING_INTERNAL_TX Notifications
+---
+
+# Incoming internal transactions
+
+In the dynamic world of blockchain, staying updated with transactions involving smart contracts is essential for maintaining a secure and efficient platform. Tatum's INCOMING\_INTERNAL\_TX notification type offers a powerful solution to help you track incoming native balance updates on a monitored address, which originated from smart contracts.\
+
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.incomingInternalTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all outgoing ETH transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "INCOMING_INTERNAL_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "txId": "0x062d236ccc044f68194a04008e98c3823271dc26160a4db9ae9303f9ecfc7bf6",
+ "blockNumber": 2913059,
+ "subscriptionType": "INCOMING_INTERNAL_TX",
+ "mempool": false,
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "amount": "0.001"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
+
+\
diff --git a/docs/notifications/notification-types/incoming-multitokens.md b/docs/notifications/notification-types/incoming-multitokens.md
new file mode 100644
index 0000000..fe55692
--- /dev/null
+++ b/docs/notifications/notification-types/incoming-multitokens.md
@@ -0,0 +1,88 @@
+---
+description: >-
+ Stay Informed on Multi-Token Transactions with INCOMING_MULTITOKEN_TX
+ Notifications
+---
+
+# Incoming MultiTokens
+
+In the dynamic world of blockchain, keeping track of multi-token transactions is crucial for maintaining a secure and efficient platform. Tatum's INCOMING\_MULTITOKEN\_TX notification type offers a powerful solution to help you stay informed about incoming multi-token transactions (e.g., ERC-1155 transfers) involving a specific address.
+
+{% hint style="info" %}
+A MultiToken (ERC-1155) could be likened to a series of limited edition art prints, where each print belongs to the same series but has its unique edition number. In this scenario, ERC-1155 tokens can represent both the series (fungible aspect) and the individual editions (non-fungible aspect) within a single smart contract, allowing for seamless management and transfer of value.
+{% endhint %}
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.incomingMultitokenTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all incoming MultiToken transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "INCOMING_MULTITOKEN_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+{% hint style="info" %}
+This notification will be fired no matter what kind of MultiToken is being transferred.
+{% endhint %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "1",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "subscriptionType": "INCOMING_MULTITOKEN_TX",
+ "blockNumber": 110827114,
+ "txId": "0xe118976ba31815f81301341b4e211825bce1393cac1c4215075177b0a6b98930",
+ "contractAddress": "0x7d3dda0430471fe460c07b1ecab35670ef4ce85b",
+ "tokenId": "1450000023306",
+ "metadataURI": "https://touhao.bj.bcebos.com/nft/metadata/1450000023306.json"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
diff --git a/docs/notifications/notification-types/incoming-native-transactions.md b/docs/notifications/notification-types/incoming-native-transactions.md
new file mode 100644
index 0000000..150bbbc
--- /dev/null
+++ b/docs/notifications/notification-types/incoming-native-transactions.md
@@ -0,0 +1,84 @@
+---
+description: Stay on Top of Your Transactions with INCOMING_NATIVE_TX Notifications
+---
+
+# Incoming native transactions
+
+In the world of blockchain, staying updated with incoming transactions is crucial for ensuring smooth operations and an optimal user experience. Tatum's INCOMING\_NATIVE\_TX notification type is designed to help you do just that โ by sending webhook notifications every time there's an incoming native balance update on a monitored address.
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.incomingNativeTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all incoming ETH transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "INCOMING_NATIVE_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "0.0001",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x0229338ee05154a406945899fb8c7bef36eb9220",
+ "subscriptionType": "INCOMING_NATIVE_TX",
+ "blockNumber": 3553920,
+ "txId": "0x21c78973a2d47b1910d79b8586c55d13c732dfb41883ee5af4318dafc66a0db9",
+ "mempool": false
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Bitcoin | Network.BITCOIN | Network.BITCOIN\_TESTNET |
+| Litecoin | Network.LITECOIN | Network.LITECOIN\_TESTNET |
+| Dogecoin | Network.DOGECOIN | Network.DOGECOIN\_TESTNET |
+| Bitcoin Cash | Network.BITCOIN\_CASH | Network.BITCOIN\_CASH\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| Solana | Network.SOLANA | Network.SOLANA\_DEVNET |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
+| XRP | Network.XRP | Network.XRP\_TESTNET |
+
diff --git a/docs/notifications/notification-types/incoming-nfts.md b/docs/notifications/notification-types/incoming-nfts.md
new file mode 100644
index 0000000..b1c0f27
--- /dev/null
+++ b/docs/notifications/notification-types/incoming-nfts.md
@@ -0,0 +1,93 @@
+---
+description: >-
+ Stay Updated on Non-Fungible Token Transactions with INCOMING_NFT_TX
+ Notifications
+---
+
+# Incoming NFTs
+
+In the ever-expanding world of blockchain, keeping track of non-fungible token (NFT) transactions is crucial for maintaining a secure and efficient platform. Tatum's INCOMING\_NFT\_TX notification type offers a powerful solution to help you stay informed about incoming non-fungible token transactions (e.g., ERC-721 / SPL transfers) involving a specific address.
+
+{% hint style="info" %}
+A non-fungible token (NFT) is a unique digital asset that represents ownership of a one-of-a-kind item or piece of content, such as digital art, virtual real estate, or collectibles. Unlike fungible tokens, NFTs are not interchangeable and each NFT has a distinct value based on its rarity, provenance, and the demand for that specific token.
+
+\
+There are different NFT standards, most known are ERC-721 on EVM chains or SPL
+{% endhint %}
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.incomingNftTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all incoming NFT transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "INCOMING_NFT_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+{% hint style="info" %}
+This notification will be fired no matter what kind of NFT is being transferred.
+{% endhint %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "1",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "subscriptionType": "INCOMING_NFT_TX",
+ "blockNumber": 110827114,
+ "txId": "0xe118976ba31815f81301341b4e211825bce1393cac1c4215075177b0a6b98930",
+ "contractAddress": "0x7d3dda0430471fe460c07b1ecab35670ef4ce85b",
+ "tokenId": "1450000023306",
+ "metadataURI": "https://touhao.bj.bcebos.com/nft/metadata/1450000023306.json"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| Solana | Network.SOLANA | Network.SOLANA\_DEVNET |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
diff --git a/docs/notifications/notification-types/incoming-tokens.md b/docs/notifications/notification-types/incoming-tokens.md
new file mode 100644
index 0000000..8f64161
--- /dev/null
+++ b/docs/notifications/notification-types/incoming-tokens.md
@@ -0,0 +1,86 @@
+---
+description: Stay on Top of Token Transactions with INCOMING_FUNGIBLE_TX Notifications
+---
+
+# Incoming Tokens
+
+In the ever-evolving world of blockchain, keeping track of fungible token transactions is essential for maintaining a secure and efficient platform. Tatum's INCOMING\_FUNGIBLE\_TX notification type offers a powerful solution to help you stay informed about incoming fungible token transactions (e.g., ERC-20 transfers) involving a specific address.
+
+{% hint style="info" %}
+A fungible token is a type of digital asset that is interchangeable and holds the same value across all its individual units. Examples of fungible tokens include popular cryptocurrencies like Bitcoin (BTC) and Ether (ETH), as well as ERC-20 tokens like Chainlink (LINK) and USD Coin (USDC), which can be easily exchanged, divided, and combined without altering their overall worth.
+{% endhint %}
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.incomingFungibleTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all incoming token transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "INCOMING_FUNGIBLE_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+{% hint style="info" %}
+This notification will be fired no matter what kind of Token arrives at the monitored address.
+{% endhint %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "1",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "subscriptionType": "INCOMING_FUNGIBLE_TX",
+ "blockNumber": 2913059,
+ "txId": "0x062d236ccc044f68194a04008e98c3823271dc26160a4db9ae9303f9ecfc7bf6",
+ "contractAddress": "0x743e8b6cc1676adae0e3243b5c011f7139c26128"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| Solana | Network.SOLANA | Network.SOLANA\_DEVNET |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
diff --git a/docs/notifications/notification-types/outgoing-failed-transactions.md b/docs/notifications/notification-types/outgoing-failed-transactions.md
new file mode 100644
index 0000000..90610bd
--- /dev/null
+++ b/docs/notifications/notification-types/outgoing-failed-transactions.md
@@ -0,0 +1,89 @@
+---
+description: Stay Ahead of Failed Transactions with OUTGOING_FAILED_TX Notifications
+---
+
+# Outgoing failed transactions
+
+In the fast-paced world of blockchain, keeping track of failed transactions is crucial for maintaining a secure and efficient platform. Tatum's OUTGOING\_FAILED\_TX notification type provides an invaluable tool to help you stay informed about transactions from monitored addresses that fail to be included in a block.
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.outgoingFailedTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all outgoing failed transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "OUTGOING_FAILED_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "amount": "0.001",
+ "blockNumber": 2913059,
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "txId": "0x062d236ccc044f68194a04008e98c3823271dc26160a4db9ae9303f9ecfc7bf6",
+ "chain": "ethereum-mainnet",
+ "subscriptionType": "OUTGOING_FAILED_TX",
+ "currency": "ETH"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+
+### Why Use OUTGOING\_FAILED\_TX Notifications?
+
+OUTGOING\_FAILED\_TX notifications offer an effective way to monitor failed transactions in real-time. By focusing on transactions that fail to be included in a block, this notification type delivers several key benefits:
+
+#### Real-time Monitoring
+
+Stay informed about failed transactions as they occur. OUTGOING\_FAILED\_TX notifications provide real-time updates, allowing you to react promptly to important events and ensuring your application or platform always has the latest information.
+
+#### Proactive Problem Solving
+
+OUTGOING\_FAILED\_TX notifications help you identify and address the reasons behind failed transactions, such as insufficient gas fees, incorrect contract addresses, or network congestion. By proactively resolving these issues, you can minimize disruptions and maintain a smooth-running platform.
+
+\
diff --git a/docs/notifications/notification-types/outgoing-internal-transactions.md b/docs/notifications/notification-types/outgoing-internal-transactions.md
new file mode 100644
index 0000000..94cc4e8
--- /dev/null
+++ b/docs/notifications/notification-types/outgoing-internal-transactions.md
@@ -0,0 +1,80 @@
+---
+description: Enhance Your Smart Contract Monitoring with OUTGOING_INTERNAL_TX Notifications
+---
+
+# Outgoing internal transactions
+
+In the dynamic world of blockchain, staying updated with transactions involving smart contracts is essential for maintaining a secure and efficient platform. Tatum's OUTGOING\_INTERNAL\_TX notification type offers a powerful solution to help you track outgoing native balance updates on a monitored smart contract.\
+
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredSmartContract = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.outgoingInternalTx({
+ address: monitoredSmartContract,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all outgoing ETH transactions on ${monitoredSmartContract}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "OUTGOING_INTERNAL_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "txId": "0x062d236ccc044f68194a04008e98c3823271dc26160a4db9ae9303f9ecfc7bf6",
+ "blockNumber": 2913059,
+ "subscriptionType": "OUTGOING_INTERNAL_TX",
+ "mempool": false,
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "amount": "0.001"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
+
+\
diff --git a/docs/notifications/notification-types/outgoing-multitokens.md b/docs/notifications/notification-types/outgoing-multitokens.md
new file mode 100644
index 0000000..3c00927
--- /dev/null
+++ b/docs/notifications/notification-types/outgoing-multitokens.md
@@ -0,0 +1,91 @@
+---
+description: >-
+ Master Outgoing Multi-Token Transactions with OUTGOING_MULTITOKEN_TX
+ Notifications
+---
+
+# Outgoing MultiTokens
+
+In the rapidly evolving world of blockchain, keeping track of multi-token transactions is essential for maintaining a secure and efficient platform. Tatum's OUTGOING\_MULTITOKEN\_TX notification type offers a powerful solution to help you stay informed about outgoing multi-token transactions (e.g., ERC-1155 transfers) from a specific address.
+
+{% hint style="info" %}
+A MultiToken (ERC-1155) could be likened to a series of limited edition art prints, where each print belongs to the same series but has its unique edition number. In this scenario, ERC-1155 tokens can represent both the series (fungible aspect) and the individual editions (non-fungible aspect) within a single smart contract, allowing for seamless management and transfer of value.
+{% endhint %}
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.outgoingMultitokenTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all outgoing MultiToken transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "OUTGOING_MULTITOKEN_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://"
+ }
+ }'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% hint style="info" %}
+This notification will be fired no matter what kind of MultiToken is being transferred.
+{% endhint %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "1",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "subscriptionType": "OUTGOING_MULTITOKEN_TX",
+ "blockNumber": 110827114,
+ "txId": "0xe118976ba31815f81301341b4e211825bce1393cac1c4215075177b0a6b98930",
+ "contractAddress": "0x7d3dda0430471fe460c07b1ecab35670ef4ce85b",
+ "tokenId": "1450000023306",
+ "metadataURI": "https://touhao.bj.bcebos.com/nft/metadata/1450000023306.json"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
diff --git a/docs/notifications/notification-types/outgoing-native-transactions.md b/docs/notifications/notification-types/outgoing-native-transactions.md
new file mode 100644
index 0000000..505139d
--- /dev/null
+++ b/docs/notifications/notification-types/outgoing-native-transactions.md
@@ -0,0 +1,81 @@
+---
+description: Master Your Outgoing Transactions with OUTGOING_NATIVE_TX Notifications
+---
+
+# Outgoing native transactions
+
+Monitoring outgoing transactions is essential for maintaining a secure and efficient blockchain platform. Tatum's OUTGOING\_NATIVE\_TX notification type offers a powerful solution to help you stay informed about outgoing native balance updates on a monitored address, simplifying your operations and enhancing user experience.
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.outgoingNativeTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all outgoing ETH transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "OUTGOING_NATIVE_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "0.001",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "subscriptionType": "OUTGOING_NATIVE_TX",
+ "blockNumber": 3553968,
+ "txId": "0xac4b590e7668ca2adfd7cceef398d9859de23e61e1a46cfa9f79ac29a1ddc541",
+ "mempool": false
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Bitcoin | Network.BITCOIN | Network.BITCOIN\_TESTNET |
+| Litecoin | Network.LITECOIN | Network.LITECOIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| Solana | Network.SOLANA | Network.SOLANA\_DEVNET |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
+| XRP | Network.XRP | Network.XRP\_TESTNET |
diff --git a/docs/notifications/notification-types/outgoing-nfts.md b/docs/notifications/notification-types/outgoing-nfts.md
new file mode 100644
index 0000000..b2a4f51
--- /dev/null
+++ b/docs/notifications/notification-types/outgoing-nfts.md
@@ -0,0 +1,91 @@
+---
+description: Monitor Non-Fungible Token Transactions with OUTGOING_NFT_TX Notifications
+---
+
+# Outgoing NFTs
+
+In the fast-paced world of blockchain, keeping track of non-fungible token (NFT) transactions is essential for maintaining a secure and efficient platform. Tatum's OUTGOING\_NFT\_TX notification type offers a powerful solution to help you stay informed about outgoing non-fungible token transactions (e.g., ERC-721 / SPL transfers) from a specific address.
+
+{% hint style="info" %}
+A non-fungible token (NFT) is a unique digital asset that represents ownership of a one-of-a-kind item or piece of content, such as digital art, virtual real estate, or collectibles. Unlike fungible tokens, NFTs are not interchangeable and each NFT has a distinct value based on its rarity, provenance, and the demand for that specific token.
+
+\
+There are different NFT standards, most known are ERC-721 on EVM chains or SPL
+{% endhint %}
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.outgoingNftTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all outgoing NFT transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "OUTGOING_NFT_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+{% hint style="info" %}
+This notification will be fired no matter what kind of NFT is being transferred.
+{% endhint %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "1",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "subscriptionType": "OUTGOING_NFT_TX",
+ "blockNumber": 110827114,
+ "txId": "0xe118976ba31815f81301341b4e211825bce1393cac1c4215075177b0a6b98930",
+ "contractAddress": "0x7d3dda0430471fe460c07b1ecab35670ef4ce85b",
+ "tokenId": "1450000023306",
+ "metadataURI": "https://touhao.bj.bcebos.com/nft/metadata/1450000023306.json"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| Solana | Network.SOLANA | Network.SOLANA\_DEVNET |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
diff --git a/docs/notifications/notification-types/outgoing-tokens.md b/docs/notifications/notification-types/outgoing-tokens.md
new file mode 100644
index 0000000..679e847
--- /dev/null
+++ b/docs/notifications/notification-types/outgoing-tokens.md
@@ -0,0 +1,86 @@
+---
+description: Stay on Top of Token Transactions with OUTGOING_FUNGIBLE_TX Notifications
+---
+
+# Outgoing Tokens
+
+In the dynamic world of blockchain, staying updated with fungible token transactions is vital for maintaining a secure and efficient platform. Tatum's OUTGOING\_FUNGIBLE\_TX notification type offers a powerful solution to help you track outgoing fungible token transactions (e.g., ERC-20 / SPL transfers) from a specific address.
+
+{% hint style="info" %}
+A fungible token is a type of digital asset that is interchangeable and holds the same value across all its individual units. Examples of fungible tokens include popular cryptocurrencies like Bitcoin (BTC) and Ether (ETH), as well as ERC-20 tokens like Chainlink (LINK) and USD Coin (USDC), which can be easily exchanged, divided, and combined without altering their overall worth.
+{% endhint %}
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.outgoingFungibleTx({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all outgoing token transactions on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "OUTGOING_FUNGIBLE_TX",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+{% hint style="info" %}
+This notification will be fired no matter what kind of Token leaves the monitored address.
+{% endhint %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "1",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "subscriptionType": "OUTGOING_FUNGIBLE_TX",
+ "blockNumber": 2913059,
+ "txId": "0x062d236ccc044f68194a04008e98c3823271dc26160a4db9ae9303f9ecfc7bf6",
+ "contractAddress": "0x743e8b6cc1676adae0e3243b5c011f7139c26128"
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| Solana | Network.SOLANA | Network.SOLANA\_DEVNET |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
diff --git a/docs/notifications/notification-types/paid-fee.md b/docs/notifications/notification-types/paid-fee.md
new file mode 100644
index 0000000..80fa091
--- /dev/null
+++ b/docs/notifications/notification-types/paid-fee.md
@@ -0,0 +1,93 @@
+---
+description: Stay Informed About Transaction Fees with PAID_FEE Notifications
+---
+
+# Paid fee
+
+In the complex world of blockchain, keeping track of transaction fees is crucial for maintaining a transparent and efficient platform. Tatum's PAID\_FEE notification type provides a valuable tool to help you stay informed about fees paid as part of transactions involving a specific address.
+
+### How to do it?
+
+{% tabs %}
+{% tab title="TypeScript / JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+(async () => {
+ const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+ const monitoredAddress = '0xF64E82131BE01618487Da5142fc9d289cbb60E9d'
+
+ const subscription = await tatum.notification.subscribe.paidFee({
+ address: monitoredAddress,
+ url: 'https://' // replace with your handler URL
+ })
+ console.log(`Now you will be notified about all paid fees on ${monitoredAddress}`)
+})()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "PAID_FEE",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+### What does the fired webhook look like?
+
+The fired notification webhook you will receive in your webhook listener will have the following format.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "currency": "ETH",
+ "chain": "ethereum-mainnet",
+ "amount": "0.000031500000168",
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "subscriptionType": "PAID_FEE",
+ "blockNumber": 2913059,
+ "txId": "0x062d236ccc044f68194a04008e98c3823271dc26160a4db9ae9303f9ecfc7bf6",
+ "mempool": false
+}
+```
+{% endcode %}
+
+### Which blockchain networks are supported?
+
+| Blockchain | Mainnet | Testnet |
+| ------------------- | ----------------------------- | ---------------------------------------------------------- |
+| Ethereum | Network.ETHEREUM | Network.ETHEREUM_SEPOLIA
Network.ETHEREUM_GOERLI
|
+| Polygon | Network.POLYGON | Network.POLYGON\_MUMBAI |
+| Binance Smart Chain | Network.BINANCE\_SMART\_CHAIN | Network.BINANCE\_SMART\_CHAIN\_TESTNET |
+| Celo | Network.CELO | Network.CELO\_ALFAJORES |
+| Klaytn | Network.KLAYTN | Network.KLATN\_BAOBAB |
+| XRP | Network.XRP | Network.XRP\_TESTNET |
+| Tron | Network.TRON | Network.TRON\_SHASTA |
+
+### Why Use PAID\_FEE Notifications?
+
+PAID\_FEE notifications offer an effective way to monitor transaction fees in real-time. By focusing on fees paid in transactions involving a specific address, this notification type delivers several key benefits:
+
+#### Real-time Monitoring
+
+Stay informed about transaction fees as they occur. PAID\_FEE notifications provide real-time updates, allowing you to react promptly to important events and ensuring your application or platform always has the latest information.
+
+#### Enhanced Transparency
+
+Receiving real-time notifications about transaction fees helps you maintain a transparent and accountable platform. Users can clearly see the fees associated with their transactions, fostering trust in your service and promoting a fair ecosystem.
+
+#### Proactive Fee Management
+
+PAID\_FEE notifications help you identify and address potential issues related to transaction fees, such as underpayment or overpayment. By proactively resolving these issues, you can minimize disruptions and maintain a smooth-running platform.
diff --git a/docs/notifications/notification-workflow/README.md b/docs/notifications/notification-workflow/README.md
new file mode 100644
index 0000000..a5cd95b
--- /dev/null
+++ b/docs/notifications/notification-workflow/README.md
@@ -0,0 +1,159 @@
+# Notification workflow
+
+Webhooks are automated messages sent from applications when certain events occur. In this case, the TatumSDK webhook system enables you to receive notifications about balance update events for a specific Ethereum address. To better understand the workflow, let's break it down into steps and present it in a simple guide. Then, we'll add a UML diagram to visualise the process.
+
+### Webhook Workflow Guide
+
+1. **Create a subscription**: Use the TatumSDK (@tatumio/tatum) to create a subscription for address events.
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const subscription = await tatum.notification.subscribe.addressEvent({
+ address: '0xF64E82131BE01618487Da5142fc9d289cbb60E9d', // replace with your address
+ url: 'https://' // replate with your URL handler
+});
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "ADDRESS_EVENT",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+This function returns an object with an `id` property - a string identifier of the created subscription.
+
+{% hint style="info" %}
+Playing with curl and having a need to define type of net, please, use query parameter `type` with `testnet` or `mainnet` values.\
+\
+Example: `https://api.tatum.io/v4/subscription?type=mainnet`\
+\
+If you do not use it explicitly `mainnet` is set by default.
+{% endhint %}
+
+2. **Monitor the address**: Tatum starts monitoring the specified address for any balance update events happening on the Ethereum blockchain.
+3. **Trigger the webhook**: Once Tatum detects an event, it fires a notification as an HTTP POST request to the webhook listener URL defined in the subscription. The request includes a JSON payload with the event details. Should you have specific access controls in place, you can whitelist these Tatum IP addresses ([TXT](https://ips.tatum.com/ips.txt) |ย [JSON](https://ips.tatum.com/ips.json)) that will fire requests to your application.
+4. **Unsubscribe from the notification**: The user can unsubscribe from the notification by calling `tatum.notification.unsubscribe(id)`.
+5. **List fired webhooks**: Users can list all fired webhooks by calling the `tatum.notification.getAllExecutedWebhooks()` operation.
+
+### UML Diagram
+
+Here's a UML diagram that focuses on the flow of subscribing, receiving events, and firing notifications. Code examples are included in the boxes for each step.
+
+```css
++------------------------+ +------------------------+
+| | | |
+| 1. User Subscribes | | 2. Monitor Address |
+| | | |
+| Code example: | | (Handled by Tatum) |
+| | | |
+| tatum.notification | +-----------+------------+
+| .subscribe | |
+| .addressEvent({ +--------------------->|
+| address: '0xF64E8...'| |
+| url: 'https://das...'| |
+| }); | |
++------------------------+ |
+ |
+ +---------------------+ |
+ | | |
+ | Event Detected on |<----------------------+
+ | the Address +---------------------->|
+ +---------------------+ |
+ |
+ |
+ |
+ v
+ +----------+----------+
+ | |
+ | 3. Process Event |
+ | (Tatum) & |
+ | Fire |
+ | Notification |
+ | |
+ | (Handled by |
+ | Webhook |
+ | Listener) |
+ | |
+ | Example |
+ | Payload: |
+ | { |
+ | "type": "BALANCE", |
+ | "amount": "0.5" |
+ | } |
+ +---------------------+
+```
+
+In this diagram, the following steps are shown:
+
+1. **Create subscription**: The user creates a subscription using the TatumSDK with the specified Ethereum address and webhook listener URL.
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum} from '@tatumio/tatum'
+
+const tatum = TatumSDK.init({network: Network.ETHEREUM})
+
+const subscription = await tatum.notification.subscribe.addressEvent({
+ address: '0xF64E82131BE01618487Da5142fc9d289cbb60E9d', // replace with your address
+ url: 'https://' // replate with your URL handler
+});
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "ADDRESS_EVENT",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+2. **Monitor Address**: Tatum monitors the specified address for balance update events happening on the Ethereum blockchain.
+3. **Receive & Fire Notification**: The webhook listener receives the event and processes the notification. An example JSON payload is provided in the diagram. Should you have specific access controls in place, you can whitelist these Tatum IP Addresses ([TXT](https://ips.tatum.com/ips.txt) |ย [JSON](https://ips.tatum.com/ips.json)) that will fire requests to your application.
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "amount": "0.001",
+ "asset": "ETH",
+ "blockNumber": 2913059,
+ "counterAddress": "0x690B9A9E9aa1C9dB991C7721a92d351Db4FaC990",
+ "txId": "0x062d236ccc044f68194a04008e98c3823271dc26160a4db9ae9303f9ecfc7bf6",
+ "type": "native",
+ "chain": "ethereum-mainnet",
+ "subscriptionType": "ADDRESS_EVENT"
+}
+```
+{% endcode %}
diff --git a/docs/notifications/notification-workflow/get-all-existing-monitoring-subscriptions.md b/docs/notifications/notification-workflow/get-all-existing-monitoring-subscriptions.md
new file mode 100644
index 0000000..68a2cd0
--- /dev/null
+++ b/docs/notifications/notification-workflow/get-all-existing-monitoring-subscriptions.md
@@ -0,0 +1,105 @@
+# Get all existing monitoring subscriptions
+
+Getting all existing monitoring subscriptions means retrieving a list of all the active webhook subscriptions that have been created through Tatum. Each subscription in the list represents a blockchain address being monitored for events, such as balance updates or contract interactions, along with the associated webhook listener URL to which the notifications are sent.
+
+When you request to get all existing monitoring subscriptions, Tatum returns a collection of subscription objects. Each object typically includes information such as the subscription identifier, the monitored blockchain address, the webhook listener URL, and any additional configuration or filters applied to the subscription.
+
+This functionality is useful for managing and reviewing your current webhook subscriptions, allowing you to keep track of which addresses are being monitored and the corresponding webhook listener URLs. By examining the list of existing subscriptions, you can ensure that you have the desired monitoring configurations in place and make any necessary adjustments or updates to your webhook subscriptions.
+
+### How to get all existing/active notifications
+
+When you request to get all active notifications using the `tatum.notification.`getAll`()` operation, Tatum returns a collection of active notifications that you have for monitoring the specified blockchain address(es) and detecting events such as balance updates or contract interactions.
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, NotificationSubscription, ResponseDto} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const {status, data}: ResponseDto = await tatum.notification.getAll()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl -i -X GET \
+ 'https://api.tatum.io/v4/subscription?pageSize=10&type=mainnet'
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+{% hint style="info" %}
+Playing with curl and having a need to define type of net, please, use query parameter `type` with `testnet` or `mainnet` values.\
+\
+Example: `https://api.tatum.io/v4/subscription?pageSize=10&type=mainnet`\
+\
+If you do not use it explicitly `mainnet` is set by default.
+{% endhint %}
+
+### Method parameters
+
+The method accepts the optional object with the following properties.
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface GetAllSubscriptionsQuery {
+ /**
+ * Number of records to return. The default is 10.
+ */
+ pageSize?: number
+ /**
+ * Number of records to skip. The default is 0.
+ */
+ offset?: number
+ /**
+ * Address to filter by.
+ */
+ address?: string
+}
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Subscription response
+
+The methods response has the following format.
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface NotificationSubscription {
+ /**
+ * ID of a subscription.
+ */
+ id: string
+ /**
+ * Blockchain network.
+ */
+ network: Network
+ /**
+ * URL of the webhook listener.
+ */
+ url: string
+ /**
+ * Type of notification subscription.
+ */
+ type: NotificationType
+ /**
+ * Address to monitor, valid for some of the types only.
+ */
+ address?: string
+}
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
diff --git a/docs/notifications/notification-workflow/get-all-sent-notifications.md b/docs/notifications/notification-workflow/get-all-sent-notifications.md
new file mode 100644
index 0000000..5a4b472
--- /dev/null
+++ b/docs/notifications/notification-workflow/get-all-sent-notifications.md
@@ -0,0 +1,184 @@
+# Get all sent notifications
+
+Getting all sent notifications means retrieving a list of all webhook notifications that have been triggered and sent by the Tatum system to the specified webhook listener URL. This list typically includes information about each fired webhook, such as the event details, timestamp, subscription identifier, and the status of the webhook (e.g., whether it was successfully delivered or encountered an error).
+
+This functionality is useful for maintaining an overview of past webhook events, analyzing the event history, troubleshooting issues, or reconciling data between the Tatum system and your application. By examining the list of fired webhooks, you can gain insights into the events that have occurred on the monitored address(es) and identify any potential issues or discrepancies in your system's handling of these events.
+
+### How to get all sent notifications
+
+When you request to get all fired webhooks using the `tatum.notification.getAllExecutedWebhooks()` operation, the Tatum system returns a collection of webhook events that have been triggered as a result of monitoring the specified blockchain address(es) and detecting events such as balance updates or contract interactions.
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, Webhook, ResponseDto} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const {status, data}: ResponseDto = await tatum.notification.getAllExecutedWebhooks()
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```bash
+curl -i -X GET \
+ 'https://api.tatum.com/v1/subscription/webhook?pageSize=10&type=mainnet'
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+using System.Text.Json;
+using Tatum;
+using Tatum.Core;
+using Tatum.Notifications.Models.Responses;
+
+// Initialize Tatum SDK
+TatumSdk tatumSdk = await TatumSdk.InitAsync();
+
+Result> executedWebhooks =
+ await tatumSdk.Notifications.GetAllExecutedWebhooks();
+
+Console.WriteLine(
+ JsonSerializer.Serialize(
+ executedWebhooks.Value,
+ new JsonSerializerOptions() { WriteIndented = true}
+ )
+);
+```
+{% endtab %}
+{% endtabs %}
+
+{% hint style="info" %}
+Playing with curl and having a need to define type of net, please, use query parameter `type` with `testnet` or `mainnet` values.\
+\
+Example:`https://api.tatum.io/v4/subscription/webhook?pageSize=10&type=mainnet`\
+\
+If you do not use it explicitly `mainnet` is set by default.
+{% endhint %}
+
+### Method parameters
+
+The method accepts the optional object with the following properties.
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface GetAllExecutedWebhooksQuery {
+ /**
+ * The number of items to return per page. Defaults to 10.
+ */
+ pageSize?: number
+ /**
+ * The page offset. Defaults to 0.
+ */
+ offset?: number
+ /**
+ * Order of the returned items. 'desc' means the most recent items are returned first. Defaults to 'desc'.
+ */
+ direction?: 'asc' | 'desc'
+ /**
+ * Filter failed notifications. If the present method will return only successful or failed results based on the filterFailed field.
+ */
+ filterFailed?: boolean
+}
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Webhook response
+
+The methods response has the following format.
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface Webhook {
+ // Type of the subscription
+ type: NotificationType
+ // Id of the notification
+ id: string
+ // Id of the subscription
+ subscriptionId: string
+ // The URL on which is notifications request sent
+ url: string
+ // The webhook payload
+ data: {
+ // Monitored address
+ address: string
+ // Amount of the transaction
+ amount: string
+ // The asset of the notification
+ asset: string
+ // The number of the block in which the transaction occurs
+ blockNumber: number
+ // Transaction hash
+ txId: string
+ // Type of the notification
+ type: string
+ // Network of the notification
+ chain: string
+ // Type of the subscription
+ subscriptionType: NotificationType
+ }
+ // Next notification execution try time - Unix timestamp
+ nextTime: number
+ // Notification execution time - Unix timestamp
+ timestamp: number
+ // Number of retries in case of the failed attempts in the past
+ retryCount: number
+ // Flag indicating whether this notification was successful or not
+ failed: boolean
+ // Response from the server in case the notification was unsuccessful
+ response: {
+ code: number
+ data: string
+ networkError: boolean
+ }
+}
+
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Example
+
+{% code overflow="wrap" lineNumbers="true" %}
+```json
+{
+ "id": "64133ffb2367c7fb4fdeb0cf",
+ "subscriptionId": "64133c4b2aef5483132f9d40",
+ "url": "https://dashboard.tatum.io/webhook-handler",
+ "type": "FAILED_TXS_PER_BLOCK",
+ "data": {
+ "address": "0x3a88ededf304949c46d1380f6960bc1de94b9dcf",
+ "amount": "0",
+ "asset": "KLAY",
+ "blockNumber": 117406122,
+ "counterAddress": "0xfdeedbb2fe5b48d5b49e435ba00e0358740d0cf5",
+ "txId": "0xa3d2bb94d1faf6e3ae85c869e73cbb8eedb73f0b0feb35601e982c087c2e3f91",
+ "type": "native",
+ "chain": "klaytn-baobab",
+ "subscriptionType": "FAILED_TXS_PER_BLOCK",
+ },
+ "nextTime": 1678983161545,
+ "timestamp": 1678983163000,
+ "retryCount": 2,
+ "failed": true,
+ "response": {
+ "code": 404,
+ "data": "NOT FOUND",
+ "networkError": false
+ }
+}
+```
+{% endcode %}
diff --git a/docs/notifications/notification-workflow/start-monitoring-of-the-address.md b/docs/notifications/notification-workflow/start-monitoring-of-the-address.md
new file mode 100644
index 0000000..eabb24d
--- /dev/null
+++ b/docs/notifications/notification-workflow/start-monitoring-of-the-address.md
@@ -0,0 +1,116 @@
+# Start monitoring of the address
+
+Starting to monitor an address means that the Tatum system begins observing the specified blockchain address for any changes, particularly balance updates. When monitoring an address, Tatum listens for incoming transactions, outgoing transactions, and internal contract interactions that may affect the balance of the address.
+
+{% hint style="info" %}
+In the context of Ethereum or any other EVM blockchain, monitoring an address involves tracking the Ethereum blockchain for transactions that involve the given address either as a sender or a receiver. The system also checks for interactions with smart contracts that may change the address's balance, such as token transfers or contract executions.
+{% endhint %}
+
+When an event related to the address is detected, Tatum triggers the webhook, sending a notification to the user's specified webhook listener URL. This allows users to receive real-time updates about events occurring on the monitored address, enabling them to react promptly to any changes in their address's balance.
+
+### How to start with address monitoring
+
+Use the TatumSDK (@tatumio/tatum) to create a subscription for address events.
+
+{% hint style="info" %}
+All possible types of notifications with detailed descriptions can be found [here](../notification-types/).
+{% endhint %}
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum, ResponseDto, AddressBasedNotification} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const subscription: ResponseDto = await tatum.notification.subscribe.addressEvent({
+ address: '0xF64E82131BE01618487Da5142fc9d289cbb60E9d', // replace with your address
+ url: 'https://' // replate with your URL handler
+})
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X POST \
+ https://api.tatum.io/v4/subscription?type=mainnet \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "type": "ADDRESS_EVENT",
+ "attr": {
+ "address": "0xF64E82131BE01618487Da5142fc9d289cbb60E9d",
+ "chain": "ETH",
+ "url": "https://<YOUR_WEBHOOK_URL>"
+ }
+ }'
+
+{% endtab %}
+{% endtabs %}
+
+This function returns an object with a `id` property - a string identifier of the created subscription. Store this identifier in order to stop the monitoring of this address in the future.
+
+{% hint style="info" %}
+Playing with curl and having a need to define type of net, please, use query parameter `type` with `testnet` or `mainnet` values.\
+\
+Example: `https://api.tatum.io/v4/subscription?type=mainnet`\
+\
+If you do not use it explicitly `mainnet` is set by default.
+{% endhint %}
+
+{% hint style="info" %}
+You can also use [Get all existing monitoring subscriptions](get-all-existing-monitoring-subscriptions.md) operation to get the correct `id`.
+{% endhint %}
+
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+interface ResponseDto {
+ /**
+ * Actual payload of the response
+ */
+ data: T
+ /**
+ * Status of the response
+ */
+ status: Status
+ /**
+ * In case of ERROR status, this field contains the error message and detailed description
+ */
+ error?: ErrorWithMessage
+}
+
+interface AddressBasedNotification {
+ /**
+ * ID of a subscription.
+ */
+ id: string
+ /**
+ * Monitored address.
+ */
+ address: string
+ /**
+ * URL of a webhook listener.
+ */
+ url: string
+}
+```
+{% endcode %}
+
+### Troubleshooting
+
+#### The address is already subscribed for a blockchain
+
+If the same address is already subscribed to a notification type, the method call will fail with the following message:
+
+`Subscription for type ADDRESS_EVENT on the address id 0xbaf6dc2e647aeb6f510f9e318856a1bcd66c5e19 and currency ETH already exists.`
+
+> #### ๐ง Only 1 unique address per notification type on a blockchain can be subscribed at the same time for the same user
+
+#### Invalid format of the address
+
+If the submitted address is in an invalid format it will respond with the following error message:
+
+`address must be a valid ETH address. Address must start with 0x and must contain 40 hexadecimal characters after and have the correct checksum.`
+
+> #### ๐ง Submitted address should be in valid format.
diff --git a/docs/notifications/notification-workflow/stop-monitoring-of-the-address.md b/docs/notifications/notification-workflow/stop-monitoring-of-the-address.md
new file mode 100644
index 0000000..23045b0
--- /dev/null
+++ b/docs/notifications/notification-workflow/stop-monitoring-of-the-address.md
@@ -0,0 +1,49 @@
+# Stop monitoring of the address
+
+Stopping the monitoring of an address means that the Tatum system will no longer push notifications via webhooks for any changes related to that address. Note that this only stops the Notification for a particular address which you are willing to stop monitoring for, incase
+
+{% hint style="info" %}
+In the context of Ethereum or any other EVM chains, stopping the monitoring of an address means that Tatum will no longer track the Ethereum blockchain for transactions involving the given address, either as a sender or a receiver. The system will also discontinue checking for interactions with smart contracts that may change the address's balance, such as token transfers or contract executions.
+{% endhint %}
+
+### How to stop monitoring of the address
+
+To stop monitoring an address, you can unsubscribe from the webhook notification by calling `tatum.notification.unsubscribe(id)` using the subscription identifier. Once unsubscribed, the Tatum system will no longer send notifications to the specified webhook listener URL about events occurring on the monitored address.
+
+{% tabs %}
+{% tab title="JavaScript / TypeScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```javascript
+// yarn add @tatumio/tatum
+import {TatumSDK, Network, Ethereum} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+await tatum.notification.unsubscribe('YOUR_SUBSCRIPTION_ID')
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="curl" %}
+curl -i -X DELETE \
+ https://api.tatum.io/v4/subscription/YOUR_SUBSCRIPTION_ID \
+ -H 'Content-Type: application/json'
+
+{% endtab %}
+{% endtabs %}
+
+{% hint style="info" %}
+Playing with curl and having a need to define type of net, please, use query parameter `type` with `testnet` or `mainnet` values.\
+\
+Example:`https://api.tatum.io/v4/subscription/{id}?type=mainnet`\
+\
+If you do not use it explicitly `mainnet` is set by default.
+{% endhint %}
+
+### Troubleshooting
+
+### Invalid subscription id
+
+If the subscription id is invalid, the following message is returned:
+
+`id should be valid id and 24 characters long, e.g. 6398ded68bfa23a9709b1b17`
diff --git a/docs/notifications/supported-types-and-blockchain-networks.md b/docs/notifications/supported-types-and-blockchain-networks.md
new file mode 100644
index 0000000..f4b2300
--- /dev/null
+++ b/docs/notifications/supported-types-and-blockchain-networks.md
@@ -0,0 +1,69 @@
+# Supported types and blockchain networks
+
+### Types of notifications you can monitor
+
+Tatum supports various types of notifications on a chain, which are designed to cover a wide range of blockchain events. These are the notifications types we offer :
+
+
+
+Incoming Transaction Notifications ๐ญ :
+
+1. [**Incoming Native Transactions**](notification-types/incoming-native-transactions.md)**:** This notification is triggered when an address you are subscribed to, receives some [Native Token](../../learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-native-tokens.md) from any address.
+2. [**Incoming Internal Transactions**](notification-types/incoming-internal-transactions.md)**:** This notification is triggered when an address you are subscribed to, receives an [Internal transaction](../../learn-blockchain/basics/what-are-transactions/what-are-internal-transactions.md) (such as transfer an asset by a smart contract).
+3. [**Incoming Fungible Transactions**](notification-types/incoming-tokens.md)**:** This notification is triggered when an address you are subscribed to, receives a [Fungible token](../../learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-fungible-tokens.md) from any address.
+4. [**Incoming NFT Transactions**](notification-types/incoming-nfts.md): This notification is triggered when an address you are subscribed to, receives a [Non Fungible Token](../../learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-non-fungible-tokens.md) (NFT's) from any address.
+5. [**Incoming MultiToken Transactions**](notification-types/incoming-multitokens.md): This notification is triggered when an address you are subscribed to, receives [MultiToken](../../learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-multitokens.md) from any address.
+
+
+
+
+
+Outgoing Transaction Notifications โ๏ธ :
+
+1. [**Outgoing Native Transactions**](notification-types/outgoing-native-transactions.md): This notification is triggered when an address you are subscribed to, sends some [Native Token](../../learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-native-tokens.md) to any address.
+2. [**Outgoing Internal Transactions**](notification-types/outgoing-internal-transactions.md): This notification is triggered when an smart contract address you are subscribed to, sends assets to another address ([Internal transaction](../../learn-blockchain/basics/what-are-transactions/what-are-internal-transactions.md)).
+3. [**Outgoing Fungible Transactions**](notification-types/outgoing-nfts.md): This notification is triggered when an address you are subscribed to, send's [Fungible tokens](../../learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-fungible-tokens.md) to any address.
+4. [**Outgoing NFT Transactions**](notification-types/outgoing-nfts.md): This notification is triggered when an address you are subscribed to, sends a [Non Fungible Token](../../learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-non-fungible-tokens.md) (NFT's) to any address.
+5. [**Outgoing MultiToken Transaction**](notification-types/outgoing-multitokens.md): This notification is triggered when an address you are subscribed to, sends a [MultiToken](../../learn-blockchain/basics/what-is-a-token-on-blockchain/what-are-multitokens.md) to any address.
+6. [**Outgoing Failed Transactions**](notification-types/outgoing-failed-transactions.md): This notification is triggered when an address you are subscribed to, initiates any transaction but it failed due to any [reason](../../learn-blockchain/basics/what-are-transactions/what-are-the-reasons-a-transaction-fails.md).
+
+
+
+
+
+Special Abstraction Notifications ๐ :
+
+1. [**Address Events**](notification-types/address-event.md): This notification is triggered when a user either receives or sends any token to any address on blockchain.
+2. [**Paid Fee**](notification-types/paid-fee.md): This notification is triggered when a fee is paid as part of a transaction involving a specific address.
+3. [**Failed Transactions in a Block** ](notification-types/failed-transactions-in-a-block.md): This notification is triggered when a block containing failed transactions is detected. This notification can be useful for monitoring and analysing failed transactions within specific blocks.
+4. [**Contract Address Log Event :**](notification-types/contract-address-log-event.md) This notification allows you to monitor specific custom log events of a smart contract.
+
+
+
+These notification types allow users to monitor a wide range of events on the blockchain, enabling them to build responsive and efficient applications.
+
+### Blockchain protocols you can work with
+
+{% hint style="info" %}
+Every type of notification has its [own guide](notification-types/), where all the supported blockchain for that type is mentioned.
+{% endhint %}
+
+Each of the notification types provided by Tatum can be used across various blockchains, depending on the blockchain family. These families include
+
+1. UTXO (Unspent Transaction Output) chains :
+ 1. Bitcoin
+ 2. Litecoin
+ 3. Dogecoin
+ 4. Bitcoin Cash
+2. EVM (Ethereum Virtual Machine) chains :
+ 1. Ethereum
+ 2. Binance Smart Chain
+ 3. Polygon
+ 4. Celo
+ 5. Klaytn
+3. Other Blockchains
+ 1. Solana
+ 2. XRP
+ 3. Tron
+
+By offering compatibility with different blockchain families, Tatum ensures that users can effectively monitor and respond to a diverse range of events, irrespective of the underlying blockchain technology
diff --git a/docs/rpc/README.md b/docs/rpc/README.md
new file mode 100644
index 0000000..a5cd2ce
--- /dev/null
+++ b/docs/rpc/README.md
@@ -0,0 +1,28 @@
+---
+description: >-
+ The RPC (Remote Procedure Call) submodule is an essential component in
+ blockchain development that enables communication and interaction with the
+ blockchain network.
+---
+
+# โ RPC
+
+## Overview
+
+RPC in blockchain development refers to the protocol and mechanism used to connect to a blockchain network and perform operations remotely. It allows developers to interact with the blockchain without running a full node locally. RPC provides a standardised interface to communicate with the blockchain network, making it easier to build decentralised applications (DApps) and interact with smart contracts.
+
+## Common Use Cases of RPC in Blockchain Development:
+
+1. Querying Blockchain Data: RPC allows developers to retrieve information from the blockchain network, such as transaction details, account balances, contract data, and block information. This data is crucial for building various applications and services on top of the blockchain.
+2. Sending Transactions: RPC enables developers to create and send transactions to the blockchain network. This is essential for initiating cryptocurrency transfers, executing smart contract functions, or interacting with decentralised applications.
+3. Deploying Smart Contracts: Through RPC, developers can deploy their smart contracts onto the blockchain network. They can specify the contract's bytecode, constructor parameters, and other relevant details to create a new instance of the smart contract.
+4. Interacting with Smart Contracts: RPC allows developers to invoke functions and interact with deployed smart contracts. They can read data from the contract, modify state variables, and trigger specific actions defined in the contract's code.
+5. Managing Accounts and Wallets: RPC facilitates the management of user accounts and wallets on the blockchain network. Developers can create new accounts, import existing ones, sign transactions, and manage cryptographic keys securely.
+
+## Benefits of Using RPC in Blockchain Development:
+
+1. Simplified Transaction Handling: By utilising RPC, developers can construct and send transactions easily, abstracting away the complexities of cryptography and blockchain protocol intricacies.
+2. Seamless Smart Contract Integration: RPC simplifies the process of interacting with smart contracts, enabling developers to build DApps and execute contract functions with ease.
+3. Enhanced Flexibility: RPC allows developers to choose between different implementations and configurations of the blockchain network, providing flexibility in deploying and interacting with their applications.
+
+In conclusion, the RPC submodule plays a crucial role in blockchain development by providing a standardised mechanism for communicating with the blockchain network. It enables developers to query data, send transactions, deploy smart contracts, interact with existing contracts, and manage accounts and wallets efficiently. Utilizing RPC simplifies the development process, enhances flexibility, and empowers developers to build robust and user-friendly decentralized applications on the blockchain.
diff --git a/docs/rpc/evm-blockchains/README.md b/docs/rpc/evm-blockchains/README.md
new file mode 100644
index 0000000..c042063
--- /dev/null
+++ b/docs/rpc/evm-blockchains/README.md
@@ -0,0 +1,39 @@
+---
+description: >-
+ EVM blockchains refer to a specific category of blockchain networks that
+ implement the Ethereum Virtual Machine (EVM) protocol.
+---
+
+# EVM Blockchains
+
+The EVM is a decentralized virtual machine that enables the execution of smart contracts and decentralized applications (DApps) on the blockchain. EVM blockchains are characterized by their ability to execute Ethereum-compatible smart contracts, utilize the same bytecode format, and offer a similar set of functionalities as the Ethereum network. Some examples of EVM blockchains include Ethereum, Binance Smart Chain (BSC), Polygon (MATIC), and many other networks compatible with Ethereum's ecosystem.
+
+Blockchains like Ethereum (ETH), Celo (CELO), Polygon (MATIC), Binance Smart Chain (BSC), and Harmony (ONE), which do not support sending multiple transactions from multiple addresses at once, there are two options to manage virtual accounts within your app:
+
+{% content-ref url="ethereum-rpc-documentation/" %}
+[ethereum-rpc-documentation](ethereum-rpc-documentation/)
+{% endcontent-ref %}
+
+{% content-ref url="polygon-rpc-documentation/" %}
+[polygon-rpc-documentation](polygon-rpc-documentation/)
+{% endcontent-ref %}
+
+{% content-ref url="haqq-rpc-documentation/" %}
+[haqq-rpc-documentation](haqq-rpc-documentation/)
+{% endcontent-ref %}
+
+{% content-ref url="optimism-rpc-documentation/" %}
+[optimism-rpc-documentation](optimism-rpc-documentation/)
+{% endcontent-ref %}
+
+{% content-ref url="flare-rpc-documentation/" %}
+[flare-rpc-documentation](flare-rpc-documentation/)
+{% endcontent-ref %}
+
+{% content-ref url="flare-rpc-documentation/" %}
+[flare-rpc-documentation](flare-rpc-documentation/)
+{% endcontent-ref %}
+
+{% content-ref url="horizen-eon-rpc-documentation/" %}
+[horizen-eon-rpc-documentation](horizen-eon-rpc-documentation/)
+{% endcontent-ref %}
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/README.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/README.md
new file mode 100644
index 0000000..f8b496c
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/README.md
@@ -0,0 +1,3 @@
+# Arbitrum RPC documentation
+
+Arbitrum is a technology suite designed to scale Ethereum. You can use Arbitrum chains to do all things you do on Ethereum โ use Web3 apps, deploy smart contracts, etc., but your transactions will be cheaper and faster. Our flagship product โ Arbitrum Rollup โ is an Optimistic rollup protocol that inherits Ethereum-level security.
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/README.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/README.md
new file mode 100644
index 0000000..1fb947d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/README.md
@@ -0,0 +1,2 @@
+# Archival information
+
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_getbadblocks.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_getbadblocks.md
new file mode 100644
index 0000000..8e91172
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_getbadblocks.md
@@ -0,0 +1,103 @@
+# debug\_getBadBlocks
+
+{% hint style="warning" %}
+There was Arbitrum hard-fork from Classic to Nitro. As the results of this, you are able to use **debug** methods from block 22 207 818 to the actual one. Other non-debug methods work from genesis block.
+{% endhint %}
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE})
+
+const result = await tatum.rpc.debugGetBadBlocks()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_getBadBlocks` is an RPC method that provides a list of the most recent bad blocks encountered by the client on the network. This feature is valuable for developers and node operators, as it enables them to identify and address any issues or anomalies related to block validation and synchronization.
+
+By accessing `debug_getBadBlocks`, they can diagnose potential problems and take appropriate actions to ensure the network's stability and integrity.
+
+### Parameters
+
+* This method does not accept any parameters.
+
+### Return Object
+
+The output is an array of objects, with each object representing the trace result of a transaction within the block. These objects include essential details such as the transaction hash and a block object, which can be null if no block was found for the transaction:
+
+* `baseFeePerGas`: The integer representation of the difficulty for this block encoded as hexadecimal.
+* `difficulty`: The integer representation of the difficulty for this block encoded as hexadecimal.
+* `extraData`: The extra data field of this block.
+* `gasLimit`: The maximum gas allowed in this block encoded as hexadecimal.
+* `gasUsed`: The total used gas by all transactions in this block encoded as hexadecimal.
+* `logsBloom`: The bloom filter for the logs of the block. Null if pending.
+* `miner`: The address of the beneficiary to whom the mining rewards were given.
+* `mixHash`: A 256-bit hash encoded as hexadecimal.
+* nonce: The hash of the generated proof-of-work. Null if pending.
+* `number`: The block number of the requested block encoded as hexadecimal. Null if pending.
+* `parentHash`: The hash of the parent block.
+* `receiptsRoot`: The root of the receipts trie of the block.
+* `sha3Uncles`: The SHA3 of the uncles data in the block.
+* size: The size of this block in bytes as an Integer value encoded as hexadecimal.
+* `stateRoot`: The root of the final state trie of the block.
+* timestamp: The Unix timestamp for when the block was collated.
+* `transactions`: An array of transaction objects with the following fields:
+ * `blockHash`: The hash of the block where this log was in. Null when it's a pending log.
+ * `blockNumber`: The block number where this log was in. Null when it's a pending log.
+ * `from`: The address of the sender.
+ * `gas`: The gas provided by the sender, encoded as hexadecimal.
+ * `gasPrice`: The gas price provided by the sender in wei, encoded as hexadecimal.
+ * maxFeePerGas: The maximum fee per gas set in the transaction.
+ * `maxPriorityFeePerGas`: The maximum priority gas fee set in the transaction.
+ * hash: The hash of the transaction.
+ * `input`: The data sent along with the transaction.
+ * nonce: The number of transactions made by the sender before this one encoded as hexadecimal.
+ * `to`: The address of the receiver. Null when it's a contract creation transaction.
+ * `transactionIndex`: The integer of the transaction's index position that the log was created from. Null when it's a pending log.
+ * `value`: The value transferred in wei encoded as hexadecimal.
+ * `type`: The transaction type.
+ * `accessList`: A list of addresses and storage keys that the transaction plans to access.
+ * `chainId`: The chain id of the transaction, if any.
+* `transactionsRoot`: The root of the transaction trie of the block.
+* `uncles`: An array of uncle hashes.
+* `rlp`: The RLP encoded header.
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_getBadBlocks",
+ "params": []
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": []
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_traceblockbyhash.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_traceblockbyhash.md
new file mode 100644
index 0000000..d20f760
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_traceblockbyhash.md
@@ -0,0 +1,110 @@
+# debug\_traceBlockByHash
+
+{% hint style="warning" %}
+There was Arbitrum hard-fork from Classic to Nitro. As the results of this, you are able to use **debug** methods from block 22 207 818 to the actual one. Other non-debug methods work from genesis block.
+{% endhint %}
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const result = await tatum.rpc.debugTraceBlockByHash(
+'0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d',
+{tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlockByHash` is an RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during each transaction, including the input, output, and depth of the calls.
+
+### Parameters
+
+* `block_hash` (required): The hash of the block to be traced.
+ * Example: `"0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an array of objects, each representing the trace result of a transaction within the block. Each object contains the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlockByHash",
+ "params": [
+ "0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c",
+ {
+ "tracer": "callTracer",
+ "timeout": "10s"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_traceblockbynumber.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_traceblockbynumber.md
new file mode 100644
index 0000000..93266b4
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_traceblockbynumber.md
@@ -0,0 +1,108 @@
+# debug\_traceBlockByNumber
+
+{% hint style="warning" %}
+There was Arbitrum hard-fork from Classic to Nitro. As the results of this, you are able to use **debug** methods from block 22 207 818 to the actual one. Other non-debug methods work from genesis block.
+{% endhint %}
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const result = await tatum.rpc.debugTraceBlockByNumber(130690340)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlockByNumber` is an RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during each transaction, including the input, output, and depth of the calls.
+
+### Parameters
+
+* `blockNumber` - `Quantity` or `String`
+ * The block number of the block to trace.
+ * Example: `"0x1"` or `"latest"`
+* `options` as `tracerConfig`(optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (required): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "10s"). Default is "5s".
+ * Example: `tracerConfig: { onlyTopCall: true, timeout: '10', }`
+
+### Return Object
+
+The return object is an array of objects, each representing the trace result of a transaction within the block. Each object contains the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlockByNumber",
+ "params": [
+ "latest",
+ {
+ "tracer": "callTracer",
+ "timeout": "10s"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_tracecall.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_tracecall.md
new file mode 100644
index 0000000..aa91ff9
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_tracecall.md
@@ -0,0 +1,123 @@
+# debug\_traceCall
+
+{% hint style="warning" %}
+There was Arbitrum hard-fork from Classic to Nitro. As the results of this, you are able to use **debug** methods from block 22 207 818 to the actual one. Other non-debug methods work from genesis block.
+{% endhint %}
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE})
+
+const result = await tatum.rpc.debugTraceCall({
+ "from": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ "to": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e87",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0xAD7C5E",
+ {tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceCall` is an RPC method that allows you to execute a given call (message), tracing the steps of its execution. This can be helpful for developers and auditors who want to inspect and analyze the internal operations and state changes of a contract call without modifying the blockchain state. This method can assist in debugging and identifying potential issues with contract execution, as well as understanding how gas is consumed during the execution of a call.
+
+### Parameters
+
+The `debug_traceCall` method accepts the following parameters:
+
+* `transaction`: An object that contains the following fields:
+ * `from`: The address from which the call is initiated. Example: `"0xa7d9ddbe1f17865597fbd27ec712455208b6b76d"`
+ * `to`: The address of the contract to be called. Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+ * `gas`: (Optional) The gas limit for the call. Example: `"0x76c0"`
+ * `gasPrice`: (Optional) The gas price for the call. Example: `"0x9184e72a000"`
+ * `value`: (Optional) The value to be transferred during the call. Example: `"0x9184e72a"`
+ * `data`: (Optional) The input data for the call, encoded as a hexadecimal string. Example: `"0x606060..."`
+* `blockNumber`: The block number for which the call should be traced. Example: `"0x1b4"`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `output`: The output data from the call.
+* `gasUsed`: The total gas used by the call.
+* `calls`: An array of objects, each representing a nested call made during the call. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "debug_traceCall",
+ "params": [
+ {
+ "from": "0xa7d9ddbe1f17865597fbd27ec712455208b6b76d",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0x1b4"
+ ]
+}
+
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_tracetransaction.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_tracetransaction.md
new file mode 100644
index 0000000..2ebc0dc
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/archival-information/debug_tracetransaction.md
@@ -0,0 +1,106 @@
+# debug\_traceTransaction
+
+{% hint style="warning" %}
+There was Arbitrum hard-fork from Classic to Nitro. As the results of this, you are able to use **debug** methods from block 22 207 818 to the actual one. Other non-debug methods work from genesis block.
+{% endhint %}
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const result = await tatum.rpc.debugTraceTransaction('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9', {tracer:'callTracer'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceTransaction` is an RPC method that allows developers to inspect and trace the execution of a specific transaction, providing valuable insight into the internal workings of the transaction, including the calls made between contracts, the state of the contracts, and any errors encountered during the transaction.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during the transaction, including the input, output, and the depth of the calls. This is particularly useful in debugging complex transactions, analyzing gas consumption, and understanding the flow of execution within smart contracts.
+
+### Parameters
+
+* `transaction_hash` (required): The hash of the transaction to trace.
+ * Example: `"0x123f681646d4a755815f9cb19e1acc8565a0c2ac"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "debug_traceTransaction",
+ "params": ["0x920d562e886a0c7c1f07ecee2ee5557f72d3056b205f8811c57e2615a3b6adb0", {"tracer":"callTracer"}],
+ "id": 2
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/README.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/README.md
new file mode 100644
index 0000000..563f334
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/README.md
@@ -0,0 +1,2 @@
+# Mempool
+
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool_content.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool_content.md
new file mode 100644
index 0000000..667013d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool_content.md
@@ -0,0 +1,129 @@
+# txpool\_content
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const content = await tatum.rpc.txPoolContent()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_content` method provides information about the transactions currently pending in the transaction pool of the Flare node. It can be helpful for developers and node operators to monitor and manage the transaction pool, especially in scenarios where it's necessary to analyze transaction congestion or prioritize specific transactions.
+
+Use cases for the `txpool_content` method include:
+
+* Analyzing network congestion by inspecting the transaction pool
+* Prioritizing transactions by gas price
+* Monitoring transactions from specific addresses
+* Debugging and troubleshooting pending transactions
+
+### Parameters
+
+This method does not require any parameters.
+
+### Return Object
+
+The `txpool_content` method returns an object with two fields: `pending` and `queued`. Each field contains a nested object with addresses as keys and their respective transactions as values.
+
+* **`pending`**: An object containing transactions that are currently pending for inclusion in the next block(s).
+* **`queued`**: An object containing transactions that are currently queued (i.e., transactions that do not meet certain criteria for inclusion in the next block, like low gas price or nonce gaps).
+
+Each transaction object includes the following information:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Request Example
+
+```json
+jsonCopy code{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "txpool_content",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x01d3b93aaade8a4066daabc8fd8482173a6ad120",
+ "gas": "0x1c9c380",
+ "gasPrice": "0x16cf917",
+ "maxFeePerGas": "0x16cf917",
+ "maxPriorityFeePerGas": "0x16cf917",
+ "hash": "0x1da9c2a8f0787bac4747c5ed1035e81f6a6745aeea43943e63635fc367b817f7",
+ "input": "0x00000000",
+ "nonce": "0xc5",
+ "to": "0x4f023eb8c6bc3116e35b67e03bf2c17f2e4f7e7e",
+ "transactionIndex": null,
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0x14f7578b57fd9f87acf5bbceb0a47f2d2d3f39b49169357457618c9634c45e8a",
+ "s": "0x775fa9976c571751a79f069f8c96f6489f286246e157a31fa99b33062631b46d"
+ }
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x03321406635a04d37cf9211f2ea3afc83a87e777",
+ "gas": "0x5208",
+ "gasPrice": "0xc570bd200",
+ "hash": "0x05f5fb8e46793fafdc924917c0afdd0afb4a53cb562542d5399234bc1eff759b",
+ "input": "0x",
+ "nonce": "0x4dc359",
+ "to": "0x77b1c86ab0aa9066803ed567e1f00973976638f6",
+ "transactionIndex": null,
+ "value": "0xb1a2b96602aa20",
+ "type": "0x0",
+ "chainId": "0xaa36a7",
+ "v": "0x1546d72",
+ "r": "0x62bd220b95ec13827c0d9b643b9beaf6f4c66d4a8ef08bb10f93d5e5c7ae0068",
+ "s": "0x467f76847cfdf43a002defe054030c1a88a9e6f56539c051c3cba46b2dd2cc89"
+ }
+ }
+ }
+ }
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool_inspect.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool_inspect.md
new file mode 100644
index 0000000..4b4b0d3
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool_inspect.md
@@ -0,0 +1,76 @@
+# txpool\_inspect
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const inspect = await tatum.rpc.txPoolInspect()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_inspect` method is a JSON-RPC method used to inspect the current transaction pool of a running node. The method allows you to view all pending transactions and their details, including transaction hashes, gas prices, and transaction data. This method is useful for developers who want to monitor the status of pending transactions or debug transaction-related issues.
+
+### Parameters
+
+The `txpool_inspect` method takes one optional parameter:
+
+* **`include`**: A string specifying the type of transactions to include in the response. Possible values are **`pending`** (default) and **`queued`**.
+
+### Return Object
+
+The `txpool_inspect` method returns an object with the following fields:
+
+* **`pending`**: An array of transaction objects, with textual data
+* **`queued`**: An array of transaction objects, with textual data
+
+## Example Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "txpool_inspect",
+ "params": [
+ "pending"
+ ],
+ "id": 1
+}
+```
+
+## Example Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": "0x4f023eB8C6BC3116E35B67E03bf2C17f2e4f7e7e: 0 wei + 30000000 gas ร 23918871 wei"
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 49999988041886240 wei + 21000 gas ร 53000000000 wei",
+ "8308536": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 100000000000000000 wei + 21000 gas ร 53000000000 wei",
+ "231211221": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 1000000000000000 wei + 21000 gas ร 11958113760 wei"
+ }
+ }
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool_status.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool_status.md
new file mode 100644
index 0000000..0482260
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/mempool/txpool_status.md
@@ -0,0 +1,64 @@
+# txpool\_status
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const status = await tatum.rpc.txPoolStatus()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_status` method returns statistics about the current state of the transaction pool. The transaction pool is a queue of pending transactions waiting to be included in the next block by miners.
+
+This method can be useful for monitoring the health of the network and analyzing the behavior of the miners. It can also be used to estimate the time it will take for a transaction to be processed, as well as to determine the gas price necessary to ensure prompt inclusion of a transaction in the next block.
+
+### Parameters
+
+This method does not take any parameters.
+
+### Return Object
+
+The `txpool_status` method returns an object with the following fields:
+
+* **`pending`**: Number of pending transactions in the pool
+* **`queued`**: Number of queued transactions in the pool
+
+### Example Request
+
+```json
+{
+ "jsonrpc":"2.0",
+ "method":"txpool_status",
+ "params":[],
+ "id":1
+}
+```
+
+### Example Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": 4,
+ "queued": 10
+ }
+}
+```
+
+In this example response, there are currently 4 pending transactions and 10 queued transactions waiting to be processed by miners.
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/README.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/README.md
new file mode 100644
index 0000000..bd96ae8
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/README.md
@@ -0,0 +1,2 @@
+# Network/Client information
+
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/eth_chainid.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/eth_chainid.md
new file mode 100644
index 0000000..1e4d4fe
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/eth_chainid.md
@@ -0,0 +1,61 @@
+# eth\_chainId
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const id = await tatum.rpc.chainId()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_chainId` method is an JSON-RPC method that allows developers to retrieve the currently configured chain ID of the network they are connected to. The chain ID is a unique identifier for different networks, such as mainnet or various testnets.
+
+This method is particularly useful when building applications that interact with multiple networks or need to verify the network to prevent replay attacks. By checking the chain ID, an application can ensure it is interacting with the intended network.
+
+### Parameters
+
+The `eth_chainId` method does not have any input parameters.
+
+### Return Object
+
+The return object contains a single field:
+
+* **`chainId`**: The hexadecimal string representation of the chain ID.
+
+### Example Request and Response
+
+JSON-RPC request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_chainId",
+ "params": []
+}
+```
+
+JSON-RPC response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0xe"
+}
+```
+
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/web3_clientversion.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/web3_clientversion.md
new file mode 100644
index 0000000..84cf527
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-client-information/web3_clientversion.md
@@ -0,0 +1,63 @@
+# web3\_clientVersion
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const version = await tatum.rpc.clientVersion()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`web3_clientVersion` is a method of the JSON-RPC API that allows the client to retrieve the current version of the client software being used by the node.
+
+This method is read-only and does not require authentication. The `web3_clientVersion` method can be used by developers to confirm the version of the client software they are using and ensure that it is compatible with their application.
+
+### Parameters
+
+This method has no parameters. It only retrieves the current version of the client software.
+
+### Return Object
+
+The `web3_clientVersion` method returns a string representing the version of the client software being used. The string includes the client name, version number, and build information.
+
+* `String` - Version string of the client software being used.
+
+### Example Request
+
+#### JSON Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "web3_clientVersion",
+ "params": [],
+ "id": 1
+}
+```
+
+### Example Response
+
+#### JSON Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 67,
+ "result": "v0.9.0"
+}
+```
+
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/README.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/README.md
new file mode 100644
index 0000000..cbe8e09
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/README.md
@@ -0,0 +1,2 @@
+# Network state
+
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_blocknumber.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_blocknumber.md
new file mode 100644
index 0000000..4975fde
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_blocknumber.md
@@ -0,0 +1,71 @@
+# eth\_blockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const latestBlock = await tatum.rpc.blockNumber()
+
+console.log(latestBlock)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_blockNumber` method returns the number of the most recent block on the blockchain. This method is commonly used to track the current state of the network, monitor for new blocks, or fetch historical data.
+
+Use cases for `eth_blockNumber` include:
+
+* Synchronising a local copy of the blockchain with the network
+* Checking the status of a transaction by comparing its block number to the current block number
+* Determining the current network state for smart contract interactions\
+
+
+### Parameters
+
+The `eth_blockNumber` method does not require any parameters.
+
+### Return Object
+
+The `eth_blockNumber` method returns a single field:
+
+* **`blockNumber`**: The number of the most recent block on the blockchain. The value is returned as a hexadecimal string.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_blockNumber",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4b7" // 1207
+}
+```
+
+In this example, the most recent block number is 1207 (`0x4b7` in hexadecimal notation).
+
+Please note that while this document provides a comprehensive description of the `eth_blockNumber` RPC method, other methods may be needed to obtain full transaction details or perform more complex tasks. Refer to the [Ethereum JSON-RPC documentation](https://eth.wiki/json-rpc/API) for more information.
+
+\
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getbalance.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getbalance.md
new file mode 100644
index 0000000..4c19d55
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getbalance.md
@@ -0,0 +1,108 @@
+# eth\_getBalance
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const balance = await tatum.rpc.getBalance('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+// dotnet add ${your_project} package Tatum
+
+var tatumSdk = await TatumSdk.InitAsync();
+
+var rpcCall = new JsonRpcCall
+{
+ Id = "1",
+ JsonRpc = "2.0",
+ Method = "eth_getBalance",
+ Params = new object[]
+ {
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ }
+};
+
+var result = await tatumSdk.Rpc.Flare.Call(rpcCall);
+```
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBalance` method is an JSON-RPC method that allows you to retrieve the balance of a specified address. This method can be used to query the balance of any address, whether it is a contract or an externally owned account (EOA). A common use case for this method is to display the current balance of a user's account in a wallet application or a decentralized application (DApp).
+
+### Parameters
+
+The method requires two parameters:
+
+1. **`address`** (required): The address of the account or contract whose balance you want to query.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`blockParameter`** (optional): The block number or block identifier to specify the point in time for which you want to query the balance.
+ * Example: `"latest"` or `"0x1"`
+
+#### Transaction Details
+
+For the purpose of this documentation, we'll also describe the `transactions` field of a full transaction object. The `eth_getBalance` method does not return transaction details, but we provide this information for completeness.
+
+A full transaction object includes the following fields:
+
+* **`hash`**: The transaction hash.
+* **`nonce`**: The number of transactions made by the sender prior to this one.
+* **`blockHash`**: The hash of the block in which the transaction was included.
+* **`blockNumber`**: The block number in which the transaction was included.
+* **`transactionIndex`**: The index of the transaction in the block.
+* **`from`**: The sender's address.
+* **`to`**: The recipient's address (or `null` for contract creation transactions).
+* **`value`**: The value transferred, in wei.
+* **`gasPrice`**: The gas price provided by the sender, in wei.
+* **`gas`**: The maximum gas allowed for the transaction.
+* **`input`**: The data sent with the transaction (typically for contract interaction).
+* **`v`**, **`r`**, **`s`**: The raw signature values of the transaction.
+
+### Return Object
+
+The method returns a single field:
+
+* `result`: The Flare balance of the specified address in wei, as a hexadecimal string.
+ * Example: `"0x1a2e1a"`, which corresponds to `1,726,666` wei.
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBalance",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1a2e1a"
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblockbyhash.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblockbyhash.md
new file mode 100644
index 0000000..bbdc30c
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblockbyhash.md
@@ -0,0 +1,137 @@
+# eth\_getBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumNova, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_NOVA}
+
+const block = await tatum.rpc.getBlockByHash('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByHash` is an JSON-RPC method that allows developers to query a specific block in the blockchain by its block hash. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+### Parameters
+
+The `eth_getBlockByHash` method accepts two parameters:
+
+1. **`blockHash`**: The hash of the block you want to retrieve information about.
+ * Type: `String`
+ * Example: `"0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b"`
+2. **`fullTransactionDetails`**: A boolean value indicating whether to return full transaction details or just transaction hashes.
+ * Type: `Boolean`
+ * Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByHash",
+ "params": ["0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b", true],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblockbynumber.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblockbynumber.md
new file mode 100644
index 0000000..93b777c
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblockbynumber.md
@@ -0,0 +1,136 @@
+# eth\_getBlockByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init<ArbitrumOne>({network: Network.ARBITRUM_ONE}
+
+const res = await tatum.rpc.blockNumber()
+
+console.log(res)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByNumber` is an JSON-RPC method that allows developers to query a specific block in the blockchain by its block number. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+### Parameters
+
+There are two required parameters for this method:
+
+1. **`blockNumber`** - The block number of the block to be retrieved. This can be a hexadecimal string or one of the predefined aliases: `"earliest"`, `"latest"`, or `"pending"`.
+
+ Example: `"0x1b4"`
+2. **`returnFullTransactionObjects`** - A boolean value that determines whether the returned block contains complete transaction objects (`true`) or only transaction hashes (`false`).
+
+ Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByNumber",
+ "params": ["latest", true]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
new file mode 100644
index 0000000..a301dac
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
@@ -0,0 +1,68 @@
+# eth\_getBlockTransactionCountByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const response = await tatum.rpc.getBlockTransactionCountByHash('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockTransactionCountByHash` is a RPC method used to fetch the number of transactions in a block by the block's hash. It is useful when you want to know the total number of transactions included in a specific block and don't want to retrieve the entire block data. This method can be used in various scenarios, such as monitoring the network activity or estimating transaction confirmation times.
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`blockHash`**: The hash of the target block for which the transaction count will be retrieved. It should be a valid 32-byte hex string.
+
+Example of the parameter:
+
+* `blockHash`: `"0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"`
+
+### Return
+
+The method returns a single value:
+
+* `transactionCount`: The total number of transactions included in the specified block. It is returned as a hexadecimal value.
+
+### Examples
+
+#### JSON-RPC request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockTransactionCountByHash",
+ "params": [
+ "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
+ ]
+}
+```
+
+#### JSON-RPC response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0xa"
+}
+```
+
+In this example, the block with the hash `"0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"` has a total of 10 transactions (indicated by the hexadecimal value `"0xa"`).
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
new file mode 100644
index 0000000..d3dc750
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
@@ -0,0 +1,63 @@
+# eth\_getBlockTransactionCountByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const response = await tatum.rpc.getBlockTransactionCountByNumber('0xAD7C5E')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBlockTransactionCountByNumber` JSON-RPC method allows you to retrieve the number of transactions in a specified block. This method is particularly useful when you need to analyze the transaction activity of a specific block. You can use it to gain insights into network usage, analyze the impact of specific events on the network, or monitor transaction congestion in certain blocks.
+
+### Parameters
+
+1. **`blockNumber`**: The block number for which the transaction count should be retrieved. It should be a hex-encoded value representing the block number.
+ * Example: `"0x1b4"` (block number 436)
+
+### Return Object
+
+The return object is a hex-encoded value representing the number of transactions in the specified block.
+
+* Example: `"0xa"` (10 transactions)
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBlockTransactionCountByNumber",
+ "params": ["0x1b4"]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0xa"
+}
+```
+
+
+
+\
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getcode.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getcode.md
new file mode 100644
index 0000000..14ad4f6
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getcode.md
@@ -0,0 +1,75 @@
+# eth\_getCode
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const code = await tatum.rpc.getCode('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getCode` method is part of the JSON-RPC API, which allows users to interact with the blockchain. This method is specifically used to retrieve the contract code (bytecode) of an account at a specific block number. It is helpful when developers need to examine the bytecode of a deployed contract or validate that the contract code on the blockchain matches the intended code.
+
+Use cases for this method could include:
+
+* Debugging a smart contract
+* Verifying the integrity of a deployed contract
+* Analyzing contract bytecode for security vulnerabilities
+
+### Parameters
+
+The `eth_getCode` method accepts two parameters:
+
+1. **`address`** (string): The address of the contract whose bytecode you want to retrieve. This should be a 20-byte address, formatted as a hex string with a `0x` prefix.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`block`** (string): The block number at which you want to retrieve the contract code. This can be specified as a hex string or one of the following special keywords:
+ * `"earliest"`: The first block in the blockchain
+ * `"latest"`: The most recent block in the blockchain
+ * `"pending"`: The upcoming block that is being mined
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The `eth_getCode` method returns a string representing the contract bytecode. The returned value is a hex string with a `0x` prefix.
+
+* If the account has contract code, the returned string will contain the bytecode.
+* If the account is not a contract or does not exist, the returned string will be `0x`.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getCode",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x606060...code_here...3839"
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getlogs.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getlogs.md
new file mode 100644
index 0000000..d885bf6
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getlogs.md
@@ -0,0 +1,111 @@
+# eth\_getLogs
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const logs = await tatum.rpc.getLogs({ address : '0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getLogs` method is an JSON-RPC method that allows developers to query logs generated by the network, specifically event logs emitted by smart contracts. These logs are an essential part of the ecosystem as they provide a way for developers to monitor contract events and track contract state changes.
+
+This method is particularly useful when building decentralized applications (dApps) that rely on events emitted by smart contracts, as it enables developers to retrieve logs based on specific filter criteria. By using `eth_getLogs`, developers can efficiently track and react to events happening on the blockchain.
+
+### Parameters
+
+The `eth_getLogs` method takes a single input parameter: an object containing the filter criteria. The filter object can have the following fields:
+
+* **`fromBlock`**: (optional) The starting block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"fromBlock": "0x1"`
+* **`toBlock`**: (optional) The ending block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"toBlock": "0x2"`
+* **`address`**: (optional) The address or list of addresses of the contracts to filter logs from. Can be a single address or an array of addresses.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`topics`**: (optional) An array of up to four 32-byte topics. Topics are order-dependent, and each topic can be an array of topic hashes or `null`.
+ * Example: `"topics": ["0x123..."]`
+* **`blockhash`**: (optional) The block hash to filter logs from. If provided, `fromBlock` and `toBlock` are ignored.
+ * Example: `"blockhash": "0xc6ef9..."`
+
+In addition to the above fields, the `transactions` field in the filter object can be specified to include full transaction details instead of just transaction hashes. This is useful when you need more information about the transactions in which the events were emitted.
+
+### Return Object
+
+The `eth_getLogs` method returns an array of log objects. Each log object contains the following fields:
+
+* **`removed`**: A boolean indicating whether the log was removed due to a chain reorganization.
+ * Example: `"removed": false`
+* **`logIndex`**: The log index position in the block.
+ * Example: `"logIndex": "0x1"`
+* **`transactionIndex`**: The transaction index position in the block.
+ * Example: `"transactionIndex": "0x0"`
+* **`transactionHash`**: The hash of the transaction that emitted the log.
+ * Example: `"transactionHash": "0x88eef..."`
+* **`blockHash`**: The hash of the block containing the log.
+ * Example: `"blockHash": "0xc6ef9..."`
+* **`blockNumber`**: The block number containing the log.
+ * Example: `"blockNumber": "0x1"`
+* **`address`**: The address of the contract that emitted the log.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`data`**: The data associated with the log.
+ * Example: `"data":"0x0000000000000000000000000000000000000000000000000000000000000020"`
+* **`topics`**: An array of topics (order-dependent) associated with the log.
+ * Example: `"topics": ["0x123..."]`
+
+## JSON-RPC Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getLogs",
+ "params": [
+ {
+ "fromBlock": "0x1",
+ "toBlock": "0x2",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "removed": false,
+ "logIndex": "0x1",
+ "transactionIndex": "0x0",
+ "transactionHash": "0x88eef...",
+ "blockHash": "0xc6ef9...",
+ "blockNumber": "0x1",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "data": "0x0000000000000000000000000000000000000000000000000000000000000020",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+This documentation provides a comprehensive overview of the `eth_getLogs` JSON-RPC method, its parameters, return objects, and JSON-RPC examples. By using this method, developers can effectively query logs generated by the network and use the retrieved data to track and react to events happening on the blockchain.
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getproof.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getproof.md
new file mode 100644
index 0000000..d16e182
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getproof.md
@@ -0,0 +1,107 @@
+# eth\_getProof
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const result = await tatum.rpc.getProof("0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+ "latest")
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getProof` is a JSON-RPC method that retrieves the Merkle-Patricia proof for an account, storage key-value pairs, and account transaction count. It allows developers to verify the state of an account or storage value at a specific block without needing the entire state trie. This method is particularly useful for light clients or off-chain applications that require proof of an account's state or specific storage values.
+
+### Parameters
+
+1. **`address`** - `Data`, 20 Bytes
+ * The address of the account.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`keys`** - `Array` of `Data`
+ * An array of storage keys for which the proof should be generated.
+ * Example: `["0x0000000000000000000000000000000000000000000000000000000000000000"]`
+3. **`blockNumber`** - `Quantity` or `String`
+ * The block number for which the proof should be generated.
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+1. **`accountProof`** - `Array` of `Data`
+ * The serialized Merkle-Patricia proof for the account.
+2. **`balance`** - `Quantity`
+ * The balance of the account at the specified block.
+3. **`codeHash`** - `Data`, 32 Bytes
+ * The hash of the code for the account at the specified block.
+4. **`nonce`** - `Quantity`
+ * The transaction count of the account at the specified block.
+5. **`storageProof`** - `Array` of `Object`
+ * An array of storage proof objects, one for each requested key, containing the following fields:
+ * `key` - `Data`, 32 Bytes: The storage key.
+ * `value` - `Quantity`: The storage value.
+ * `proof` - `Array` of `Data`: The serialized Merkle-Patricia proof for the key-value pair.
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getProof",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ [
+ "0x0000000000000000000000000000000000000000000000000000000000000000"
+ ],
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": {
+ "accountProof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ],
+ "balance": "0xde0b6b3a7640000",
+ "codeHash": "0x...",
+ "nonce": "0x1",
+ "storageProof": [
+ {
+ "key": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "value": "0xde0b6b3a7640000",
+ "proof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ]
+ }
+ ]
+ }
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getstorageat.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getstorageat.md
new file mode 100644
index 0000000..0b4d856
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getstorageat.md
@@ -0,0 +1,69 @@
+# eth\_getStorageAt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const response = await tatum.rpc.getStorageAt('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', '0x0')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getStorageAt` is an JSON-RPC method that allows you to query the storage value of a contract at a given position. It can be used to inspect the internal state of a smart contract. This method is particularly useful for developers, auditors, and analysts who want to examine contract storage values for various purposes, such as debugging, verifying contract behavior, or analyzing data.
+
+### Parameters
+
+`eth_getStorageAt` accepts three parameters:
+
+1. **`address`**: The address of the contract you want to query.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`position`**: The storage position (slot) you want to query.
+ * Example: `"0x0"`
+3. **`blockParameter`**: The block number, block hash, or one of the string literals (`"earliest"`, `"latest"` or `"pending"`), representing the point in the blockchain to query the storage value.
+ * Example: `"latest"`
+
+### Return Object
+
+The return object is a single string value, representing the storage value at the given position in the contract.
+
+* `result`: The storage value in a 32-byte (64 character) hexadecimal format.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getStorageAt",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "0x0",
+ "latest"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x0000000000000000000000000000000000000000000000000000000000000123"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
new file mode 100644
index 0000000..7850e2d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
@@ -0,0 +1,102 @@
+# eth\_getTransactionByBlockHashAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const tx = await tatum.rpc.getTransactionByBlockHashAndIndex('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d', 0)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockHash` (required): The hash of the block containing the transaction.
+ * Example: `"0x9a9a2a0d69b4ff48f7a2a8a26d135e1dbcbd3c3be3e8a3c90de0bcb104e4c4b4"`
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a hexadecimal value.
+ * Example: `"0x0"`
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockHashAndIndex",
+ "params": [
+ "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "0x0"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "from": "0x37a53636ee68f59d9346aabcfc0d36011d9d5b35",
+ "gas": "0x5b8d80",
+ "gasPrice": "0x59682f0a",
+ "maxFeePerGas": "0x59682f10",
+ "maxPriorityFeePerGas": "0x59682f00",
+ "hash": "0x40a0f78e346d15b05efa1861149e5999ea48197dcf104d69160d45b08b7a5118",
+ "input": "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",
+ "nonce": "0xec0",
+ "to": "0x8febc74c26129c8d7e60288c6dccc75eb494aa3c",
+ "transactionIndex": "0x0",
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0xccf7b8fd2d63782e651f4d9650c0ed1a430060fd947d97b6504876f8ea16b357",
+ "s": "0x50c56d90105b1b8aa475c9500137e9b7c4f0a331fee076bc395a695dc471dc05"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
new file mode 100644
index 0000000..9f8a91e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
@@ -0,0 +1,102 @@
+# eth\_getTransactionByBlockNumberAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const tx = await tatum.rpc.getTransactionByBlockNumberAndIndex('0xAD7C5E', 0)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockNumber` (required): The hash of the block containing the transaction.
+ * Example: `"0x316624"`
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a hexadecimal value.
+ * Example: `"0x0"`
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockNumberAndIndex",
+ "params": [
+ "0x316624",
+ "0x0"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "from": "0x37a53636ee68f59d9346aabcfc0d36011d9d5b35",
+ "gas": "0x5b8d80",
+ "gasPrice": "0x59682f0a",
+ "maxFeePerGas": "0x59682f10",
+ "maxPriorityFeePerGas": "0x59682f00",
+ "hash": "0x40a0f78e346d15b05efa1861149e5999ea48197dcf104d69160d45b08b7a5118",
+ "input": "0xb1dc65a4000129d4314ec8c4bafb6468cc9d3c21de025fa54002558c9f76aec833406ab600000000000000000000000000000000000000000000000000000000001ccc01f18333a24416e0a0be9cdb78505c9c3c27fa42bccdbe6456cd6c1fc81bee7c0e00000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000022000000000000000000000000000000000000000000000000000000000000003a001000000010100010100010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000003d150000000000000000000000000000000000000000000000000000000000003d17325325668a08b50a9587fd4605ce02dbc5ccefc4883a41b485ff4dc4a4f86f1e0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000a8690000000000000000000000000000000000000000000000000000009d29229e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ba6547e7b549a1f180c5ad4f2e2e7104fecb8373482f3de6574ecbeefdc9be9dfd9f1934768a23584f1508adad8a7bbfbe445a27bed9f1d4538d4e4c9e458b0c5274b6f714f5aee9a8d56aeb8957b6da6b8914e445a46dcd349737b2eb7d72132e41926d07355de577b13e6ec8e55eaaf628b333197a8d1292bed1c375e891e1da1d519aabbebcc6d299b575b7bef506e2db9493de6f0cfdb0436a81597eb155edc63a8ea655a9b405a0c41c923b1734d78b5d9812f36a602ace3d8c5b22beb9519e406f32de9768e518f2b253a95364a9a2838ba5023c52d503fe8fa811c8803399679a19513671b13d4040e46be74e152d39be4f68bfecaa57d27965ba724a09464734faf7230b19e04f4aa581f10066884e2f402af36f0cdbf08de95e190f4f31fd3b718c1317b65fba9e7ea45ef6180e4861839c6395c814214ee8d56b28ba19f47b6b80f43045635432971b30f2bfb3a26a53ca502bf21fa598c5ddb934b000000000000000000000000000000000000000000000000000000000000000b3ab737e679aefe131ad3efc850fd2c50b316aabcdaa4368587d9606df84b3590541698c7c5538111187964e1b3f39fa033033bb7cab30275ea11b912089663ec43243ff37fa9d2cce04dfce25738c3a484d42f8d8a2c6be226627606f75788ee0e777481b5bd100d00d118bddd18e8726f7a54333b6228f57fa3237799079eb56e6e0ac0cb0f334d23f7284e2dcb2f463d8104fc198389e42a9d1bad1dcfe983115d3d85474db611a6e82b2f61b8d93efa77bc039bd5b3b0f02a7fc587d4a12a0daf256c21ecb9664e6c90c2bfb72a753ff008d3306f7cd4c823df6685fc4cba1514ed132d6367a8f99fba241fc6ef6917f5279ebfdd3e05a296e5c4d77a5463037d7c8180d0644d7e90123918c30fca011d710201ceabcae277924f32ff6b9d0e4d285eb59b4b56d3af8d4b2ab1a39ec2d4324e49deea661cbd43f21cbdc76a10a14055ecdd3251a5860c3bb02bcc1f21da5564fc05adbac70c7565fb5f44b8",
+ "nonce": "0xec0",
+ "to": "0x8febc74c26129c8d7e60288c6dccc75eb494aa3c",
+ "transactionIndex": "0x0",
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0xccf7b8fd2d63782e651f4d9650c0ed1a430060fd947d97b6504876f8ea16b357",
+ "s": "0x50c56d90105b1b8aa475c9500137e9b7c4f0a331fee076bc395a695dc471dc05"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionbyhash.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionbyhash.md
new file mode 100644
index 0000000..5304d45
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionbyhash.md
@@ -0,0 +1,92 @@
+# eth\_getTransactionByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const tx = await tatum.rpc.getTransactionByHash('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByHash` is an JSON-RPC method that allows you to query transaction details based on its hash. This method is useful when you want to retrieve information about a specific transaction, such as its sender, receiver, value, and more. Common use cases include tracking transaction status, monitoring incoming transactions, or analyzing historical transaction data.
+
+### Parameters
+
+The `eth_getTransactionByHash` method takes one parameter:
+
+* **`transactionHash`**: The hash of the transaction you want to retrieve. This should be a 32-byte hash string with a `0x` prefix.
+ * Example: `"0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"`
+
+### Return Object
+
+The method returns a transaction object with the following fields:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getTransactionByHash",
+ "params": ["0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"],
+ "id": 1
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "from": "0x53e8577c4347c365e4e0da5b57a589cb6f2ab848",
+ "gas": "0x3c524",
+ "gasPrice": "0x306dc421e",
+ "hash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "input": "0x50bb4e7f00000000000000000000000074b4551c177592a908c6ab9ce671bfe8c1b5bd40000000000000000000000000000000000000000000000000000056b990e70e000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000006068747470733a2f2f6574682d6d61696e6e65742e672e616c6368656d792e636f6d2f76322f72646f704c505054424a31536f786b2d555179306b7464676f4b45326146637a2f6765744e4654732f3f6f776e65723d766974616c696b2e657468",
+ "nonce": "0xc97",
+ "to": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "transactionIndex": "0x4",
+ "value": "0x0",
+ "type": "0x0",
+ "chainId": "0xaa36a7",
+ "v": "0x1546d71",
+ "r": "0xf89098451217613aa4abbb3f8988e75e20ae948d07bf8b26c472bc9bda50c9d9",
+ "s": "0x15cfb5b34bcb23730aeadc28df3b66fa9cf28103ffc8b557d76f0c1df078028e"
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactioncount.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactioncount.md
new file mode 100644
index 0000000..0f0cb84
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactioncount.md
@@ -0,0 +1,74 @@
+# eth\_getTransactionCount
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const result = await tatum.rpc.getTransactionCount('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', 'pending')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getTransactionCount` method is an JSON-RPC method that retrieves the number of transactions sent from a given address. It is a useful method for developers who need to keep track of an account's nonce value to avoid transaction collisions or incorrect order of execution. The nonce value is essential for ensuring transaction uniqueness and preventing replay attacks.
+
+Use cases for this method include:
+
+* Determining the nonce value for a new transaction to be sent from a specific address
+* Monitoring the number of transactions sent by an address to observe its activity
+* Troubleshooting transaction issues and verifying if a transaction was submitted successfully
+
+### Parameters
+
+The `eth_getTransactionCount` method accepts two parameters:
+
+1. **`address`** - The address whose transaction count will be retrieved.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`blockParameter`** - A string indicating the block number or block state to consider when retrieving the transaction count.
+ * Possible values: `"earliest"`, `"latest"`, `"pending"`, or a specific block number in hexadecimal format
+ * Example: `"latest"`
+
+### Return Object
+
+The method returns a single value:
+
+* **`transactionCount`** - A hexadecimal representation of the number of transactions sent from the specified address.
+ * Example: `"0x1e"`
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionCount",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1e"
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionreceipt.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionreceipt.md
new file mode 100644
index 0000000..1c6cdc2
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_gettransactionreceipt.md
@@ -0,0 +1,129 @@
+# eth\_getTransactionReceipt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const tx = await tatum.rpc.getTransactionReceipt('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+// dotnet add ${your_project} package Tatum
+
+var tatumSdk = await TatumSdk.InitAsync();
+
+var rpcCall = new JsonRpcCall
+{
+ Id = "1",
+ JsonRpc = "2.0",
+ Method = "eth_getTransactionReceipt",
+ Params = new object[]
+ {
+ "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"
+ }
+};
+
+var result = await tatumSdk.Rpc.Arbitrum.Call(rpcCall);
+```
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionReceipt` is an JSON-RPC method that retrieves the transaction receipt of a given transaction hash. This method is particularly useful when you need to obtain detailed information about a transaction's execution, such as its status (success or failure), gas usage, and logs (events). Common use cases include checking the status of a transaction after it has been mined or inspecting the events emitted by a smart contract during a specific transaction.
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`transactionHash`**: The hash of the transaction for which you want to obtain the receipt.
+ * Example: `"0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+* **`transactionHash`**: The hash of the transaction.
+* **`transactionIndex`**: The transaction's index position in the block.
+* **`blockHash`**: The hash of the block where this transaction was mined.
+* **`blockNumber`**: The block number where this transaction was mined.
+* **`from`**: The address of the sender.
+* **`to`**: The address of the receiver. `null` when it's a contract creation transaction.
+* **`cumulativeGasUsed`**: The total amount of gas used when this transaction was executed in the block.
+* **`gasUsed`**: The amount of gas used by this specific transaction alone.
+* **`contractAddress`**: The address of the contract created, if the transaction was a contract creation. Otherwise, `null`.
+* **`logs`**: An array of log objects, which were emitted during the transaction.
+* **`logsBloom`**: A 256-byte bloom filter, which is a compressed representation of the logs emitted during the transaction.
+* **`status`**: The status of the transaction's execution. `"0x1"` indicates success, while `"0x0"` indicates failure.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionReceipt",
+ "params": [
+ "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "contractAddress": null,
+ "cumulativeGasUsed": "0x7ad81",
+ "effectiveGasPrice": "0x306dc421e",
+ "from": "0x53e8577c4347c365e4e0da5b57a589cb6f2ab848",
+ "gasUsed": "0x3c518",
+ "logs": [
+ {
+ "address": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "topics": [
+ "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "0x00000000000000000000000074b4551c177592a908c6ab9ce671bfe8c1b5bd40",
+ "0x000000000000000000000000000000000000000000000000000056b990e70e00"
+ ],
+ "data": "0x",
+ "blockNumber": "0x316624",
+ "transactionHash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "transactionIndex": "0x4",
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "logIndex": "0x3",
+ "removed": false
+ }
+ ],
+ "logsBloom": "0x00000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000020000010000000000000800000000000000000000000010000040000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000100000000000000000000000000000000002000000200000000000100000000000800000000000000000000020000000000000000000000200000000000000000000000000000000000000000000",
+ "status": "0x1",
+ "to": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "transactionHash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "transactionIndex": "0x4",
+ "type": "0x0"
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getunclecountbyblockhash.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
new file mode 100644
index 0000000..b7d645e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
@@ -0,0 +1,70 @@
+# eth\_getUncleCountByBlockHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const result = await tatum.rpc.getUncleCountByBlockHash('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the network and to analyze the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralization of the network. The inclusion of uncles helps prevent centralization and ensures the mining process remains competitive.
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockHash`: The hash of the block for which you want to get the uncle count.
+ * Example value: `"0x3a3e528dcd6e05a614c9241b0a9296db961fa6a92e05af9f6c0d7d2f6bc92f7a"`
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockHash` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockHash",
+ "params": [
+ "0x3a3e528dcd6e05a614c9241b0a9296db961fa6a92e05af9f6c0d7d2f6bc92f7a"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x1"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
new file mode 100644
index 0000000..1b55bfc
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
@@ -0,0 +1,71 @@
+# eth\_getUncleCountByBlockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const result = await tatum.rpc.getUncleCountByBlockNumber('0xAD7C5E')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the network and to analyze the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralization of the network. The inclusion of uncles helps prevent centralization and ensures the mining process remains competitive.
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockNumber`: The number of the block for which you want to get the uncle count.
+ * Example value: `"0x12345"`
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockNumber` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockNumber",
+ "params": [
+ "0x12345"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x1"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
+\
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/README.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/README.md
new file mode 100644
index 0000000..1b1ccbc
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/README.md
@@ -0,0 +1,2 @@
+# Transaction
+
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_estimategas.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_estimategas.md
new file mode 100644
index 0000000..43404a7
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_estimategas.md
@@ -0,0 +1,92 @@
+# eth\_estimateGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const estimate = await tatum.rpc.estimateGas({
+ "from": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ "to": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e87",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060"
+ })
+
+ tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_estimateGas` is an JSON-RPC method that estimates the amount of gas required to execute a given transaction. This method can be used to determine the gas cost before sending a transaction, allowing developers to better predict the gas fees and avoid issues like out-of-gas errors.
+
+Use cases for `eth_estimateGas` include:
+
+* Estimating gas costs for contract deployments
+* Estimating gas costs for contract function calls
+* Estimating gas costs for standard transfers
+
+### Parameters
+
+The `eth_estimateGas` method takes a single parameter, an object representing the transaction details. The fields in the transaction object include:
+
+* **`from`** (optional, string): The address that the transaction is sent from.
+ * Example: `"from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`to`** (optional, string): The address the transaction is sent to.
+ * Example: `"to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`gas`** (optional, string): The maximum amount of gas provided for the transaction.
+ * Example: `"gas": "0x76c0"`
+* **`gasPrice`** (optional, string): The price of gas in wei.
+ * Example: `"gasPrice": "0x9184e72a000"`
+* **`value`** (optional, string): The amount of ZEN to send in the transaction, in wei.
+ * Example: `"value": "0xde0b6b3a7640000"`
+* **`data`** (optional, string): The data payload of the transaction, typically used for contract function calls or contract deployment.
+ * Example: `"data": "0x606060..."`
+* **`nonce`** (optional, string): The transaction count of the `from` address.
+ * Example: `"nonce": "0x1"`
+
+### Return Object
+
+The return value of the `eth_estimateGas` method is a single field:
+
+* `gasEstimate` (string): The estimated gas cost for the transaction, represented as a hexadecimal string.
+ * Example: `"0x5208"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_estimateGas",
+ "params": [
+ {
+ "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060..."
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x5208"
+}
+```
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_gasprice.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_gasprice.md
new file mode 100644
index 0000000..40783d1
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_gasprice.md
@@ -0,0 +1,60 @@
+# eth\_gasPrice
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumNova, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_NOVA}
+
+const gasPrice = await tatum.rpc.gasPrice()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_gasPrice` method is an JSON-RPC method used to estimate the average gas price required for transactions in the network. This method provides a suggestion for the gas price to be used in a transaction to increase the likelihood of it being mined and included in a block in a reasonable amount of time. The `eth_gasPrice` method is particularly useful for developers and users who want to create and send transactions, as it helps them estimate the appropriate gas price to ensure timely processing.
+
+### Parameters
+
+The `eth_gasPrice` method does not require any parameters.
+
+### Return Value
+
+The `eth_gasPrice` method returns a single value as a hexadecimal string:
+
+* `gasPrice`: The estimated average gas price in wei. Example: `"0x4a817c800"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_gasPrice",
+ "params": []
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4a817c800"
+}
+```
+
+By using the `eth_gasPrice` method, developers and users can estimate the appropriate gas price for their transactions, improving the overall user experience and ensuring that their transactions are processed in a timely manner.
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_maxpriorityfeepergas.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
new file mode 100644
index 0000000..767f045
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
@@ -0,0 +1,62 @@
+# eth\_maxPriorityFeePerGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const gasPrice = await tatum.rpc.maxPriorityFeePerGas()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_maxPriorityFeePerGas` RPC method is used to retrieve the maximum priority fee per gas set by the user for a transaction. This method can be used to determine the maximum fee that can be paid for a transaction to be included in a block quickly.
+
+### Use case
+
+This method is particularly useful when the user wants to ensure that a transaction is processed quickly, even in a congested network where transaction fees may fluctuate rapidly. By setting a high maximum priority fee per gas, the user can ensure that the transaction is processed as quickly as possible.
+
+### Parameters
+
+`None.`
+
+## Return Object
+
+* `maxPriorityFeePerGas` - The maximum priority fee per gas the user is willing to pay, in wei.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_maxPriorityFeePerGas",
+ "params": [],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x3b9aca00"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_sendrawtransaction.md b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_sendrawtransaction.md
new file mode 100644
index 0000000..7415f20
--- /dev/null
+++ b/docs/rpc/evm-blockchains/arbitrum-rpc-documentation/transaction/eth_sendrawtransaction.md
@@ -0,0 +1,62 @@
+# eth\_sendRawTransaction
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, ArbitrumOne, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ARBITRUM_ONE}
+
+const gasPrice = await tatum.rpc.sendRawTransaction('0x0000.......')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_sendRawTransaction` RPC method is used to send a signed and serialized transaction to the network. This method is particularly useful when you want to have full control over the signing process, e.g., when using hardware wallets, cold storage, or custom signing libraries. It can be utilized in various use cases, such as transferring, interacting with smart contracts, or deploying new contracts.
+
+### Parameters
+
+The method accepts a single parameter:
+
+* **`data`**: The signed and serialized transaction data as a hexadecimal string.
+
+### Return Value
+
+The method returns a single value:
+
+* `transactionHash`: The hash of the submitted transaction as a hexadecimal string, e.g., `"0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"`.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_sendRawTransaction",
+ "params": [
+ "0xf86d8201...94a7bc"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/README.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/README.md
new file mode 100644
index 0000000..01876d5
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/README.md
@@ -0,0 +1,3 @@
+# Avalanche RPC documentation
+
+Avalanche is a fully EVM-compatible sidechain and smart contract platform built with massive scalability in mind. Interact with this blockchain network via JSON-RPC methods.
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/README.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/README.md
new file mode 100644
index 0000000..1fb947d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/README.md
@@ -0,0 +1,2 @@
+# Archival information
+
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_traceblockbyhash.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_traceblockbyhash.md
new file mode 100644
index 0000000..2b77e9a
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_traceblockbyhash.md
@@ -0,0 +1,106 @@
+# debug\_traceBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const result = await tatum.rpc.debugTraceBlockByHash(
+'0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d',
+{tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlockByHash` is an RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during each transaction, including the input, output, and depth of the calls.
+
+### Parameters
+
+* `block_hash` (required): The hash of the block to be traced.
+ * Example: `"0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an array of objects, each representing the trace result of a transaction within the block. Each object contains the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlockByHash",
+ "params": [
+ "0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c",
+ {
+ "tracer": "callTracer",
+ "timeout": "10s"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_traceblockbynumber.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_traceblockbynumber.md
new file mode 100644
index 0000000..33bd555
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_traceblockbynumber.md
@@ -0,0 +1,104 @@
+# debug\_traceBlockByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const result = await tatum.rpc.debugTraceBlockByNumber(35129611)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlockByNumber` is an RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during each transaction, including the input, output, and depth of the calls.
+
+### Parameters
+
+* `blockNumber` - `Quantity` or `String`
+ * The block number of the block to trace.
+ * Example: `"0x1"` or `"latest"`
+* `options` as `tracerConfig`(optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (required): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "10s"). Default is "5s".
+ * Example: `tracerConfig: { onlyTopCall: true, timeout: '10', }`
+
+### Return Object
+
+The return object is an array of objects, each representing the trace result of a transaction within the block. Each object contains the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlockByNumber",
+ "params": [
+ "latest",
+ {
+ "tracer": "callTracer",
+ "timeout": "10s"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_tracecall.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_tracecall.md
new file mode 100644
index 0000000..e905b07
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_tracecall.md
@@ -0,0 +1,119 @@
+# debug\_traceCall
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const result = await tatum.rpc.debugTraceCall({
+ "from": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ "to": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e87",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0xAD7C5E",
+ {tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceCall` is an RPC method that allows you to execute a given call (message), tracing the steps of its execution. This can be helpful for developers and auditors who want to inspect and analyze the internal operations and state changes of a contract call without modifying the blockchain state. This method can assist in debugging and identifying potential issues with contract execution, as well as understanding how gas is consumed during the execution of a call.
+
+### Parameters
+
+The `debug_traceCall` method accepts the following parameters:
+
+* `transaction`: An object that contains the following fields:
+ * `from`: The address from which the call is initiated. Example: `"0xa7d9ddbe1f17865597fbd27ec712455208b6b76d"`
+ * `to`: The address of the contract to be called. Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+ * `gas`: (Optional) The gas limit for the call. Example: `"0x76c0"`
+ * `gasPrice`: (Optional) The gas price for the call. Example: `"0x9184e72a000"`
+ * `value`: (Optional) The value to be transferred during the call. Example: `"0x9184e72a"`
+ * `data`: (Optional) The input data for the call, encoded as a hexadecimal string. Example: `"0x606060..."`
+* `blockNumber`: The block number for which the call should be traced. Example: `"0x1b4"`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `output`: The output data from the call.
+* `gasUsed`: The total gas used by the call.
+* `calls`: An array of objects, each representing a nested call made during the call. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "debug_traceCall",
+ "params": [
+ {
+ "from": "0xa7d9ddbe1f17865597fbd27ec712455208b6b76d",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0x1b4"
+ ]
+}
+
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_tracetransaction.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_tracetransaction.md
new file mode 100644
index 0000000..1d1efa1
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/archival-information/debug_tracetransaction.md
@@ -0,0 +1,102 @@
+# debug\_traceTransaction
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const result = await tatum.rpc.debugTraceTransaction('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9', {tracer:'callTracer'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceTransaction` is an RPC method that allows developers to inspect and trace the execution of a specific transaction, providing valuable insight into the internal workings of the transaction, including the calls made between contracts, the state of the contracts, and any errors encountered during the transaction.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during the transaction, including the input, output, and the depth of the calls. This is particularly useful in debugging complex transactions, analyzing gas consumption, and understanding the flow of execution within smart contracts.
+
+### Parameters
+
+* `transaction_hash` (required): The hash of the transaction to trace.
+ * Example: `"0x123f681646d4a755815f9cb19e1acc8565a0c2ac"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "debug_traceTransaction",
+ "params": ["0x920d562e886a0c7c1f07ecee2ee5557f72d3056b205f8811c57e2615a3b6adb0", {"tracer":"callTracer"}],
+ "id": 2
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/README.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/README.md
new file mode 100644
index 0000000..563f334
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/README.md
@@ -0,0 +1,2 @@
+# Mempool
+
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool_content.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool_content.md
new file mode 100644
index 0000000..c3a8ba0
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool_content.md
@@ -0,0 +1,129 @@
+# txpool\_content
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const content = await tatum.rpc.txPoolContent()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_content` method provides information about the transactions currently pending in the transaction pool of the Flare node. It can be helpful for developers and node operators to monitor and manage the transaction pool, especially in scenarios where it's necessary to analyze transaction congestion or prioritize specific transactions.
+
+Use cases for the `txpool_content` method include:
+
+* Analyzing network congestion by inspecting the transaction pool
+* Prioritizing transactions by gas price
+* Monitoring transactions from specific addresses
+* Debugging and troubleshooting pending transactions
+
+### Parameters
+
+This method does not require any parameters.
+
+### Return Object
+
+The `txpool_content` method returns an object with two fields: `pending` and `queued`. Each field contains a nested object with addresses as keys and their respective transactions as values.
+
+* **`pending`**: An object containing transactions that are currently pending for inclusion in the next block(s).
+* **`queued`**: An object containing transactions that are currently queued (i.e., transactions that do not meet certain criteria for inclusion in the next block, like low gas price or nonce gaps).
+
+Each transaction object includes the following information:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Request Example
+
+```json
+jsonCopy code{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "txpool_content",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x01d3b93aaade8a4066daabc8fd8482173a6ad120",
+ "gas": "0x1c9c380",
+ "gasPrice": "0x16cf917",
+ "maxFeePerGas": "0x16cf917",
+ "maxPriorityFeePerGas": "0x16cf917",
+ "hash": "0x1da9c2a8f0787bac4747c5ed1035e81f6a6745aeea43943e63635fc367b817f7",
+ "input": "0x00000000",
+ "nonce": "0xc5",
+ "to": "0x4f023eb8c6bc3116e35b67e03bf2c17f2e4f7e7e",
+ "transactionIndex": null,
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0x14f7578b57fd9f87acf5bbceb0a47f2d2d3f39b49169357457618c9634c45e8a",
+ "s": "0x775fa9976c571751a79f069f8c96f6489f286246e157a31fa99b33062631b46d"
+ }
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x03321406635a04d37cf9211f2ea3afc83a87e777",
+ "gas": "0x5208",
+ "gasPrice": "0xc570bd200",
+ "hash": "0x05f5fb8e46793fafdc924917c0afdd0afb4a53cb562542d5399234bc1eff759b",
+ "input": "0x",
+ "nonce": "0x4dc359",
+ "to": "0x77b1c86ab0aa9066803ed567e1f00973976638f6",
+ "transactionIndex": null,
+ "value": "0xb1a2b96602aa20",
+ "type": "0x0",
+ "chainId": "0xaa36a7",
+ "v": "0x1546d72",
+ "r": "0x62bd220b95ec13827c0d9b643b9beaf6f4c66d4a8ef08bb10f93d5e5c7ae0068",
+ "s": "0x467f76847cfdf43a002defe054030c1a88a9e6f56539c051c3cba46b2dd2cc89"
+ }
+ }
+ }
+ }
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool_inspect.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool_inspect.md
new file mode 100644
index 0000000..32be641
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool_inspect.md
@@ -0,0 +1,76 @@
+# txpool\_inspect
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const inspect = await tatum.rpc.txPoolInspect()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_inspect` method is a JSON-RPC method used to inspect the current transaction pool of a running node. The method allows you to view all pending transactions and their details, including transaction hashes, gas prices, and transaction data. This method is useful for developers who want to monitor the status of pending transactions or debug transaction-related issues.
+
+### Parameters
+
+The `txpool_inspect` method takes one optional parameter:
+
+* **`include`**: A string specifying the type of transactions to include in the response. Possible values are **`pending`** (default) and **`queued`**.
+
+### Return Object
+
+The `txpool_inspect` method returns an object with the following fields:
+
+* **`pending`**: An array of transaction objects, with textual data
+* **`queued`**: An array of transaction objects, with textual data
+
+## Example Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "txpool_inspect",
+ "params": [
+ "pending"
+ ],
+ "id": 1
+}
+```
+
+## Example Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": "0x4f023eB8C6BC3116E35B67E03bf2C17f2e4f7e7e: 0 wei + 30000000 gas ร 23918871 wei"
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 49999988041886240 wei + 21000 gas ร 53000000000 wei",
+ "8308536": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 100000000000000000 wei + 21000 gas ร 53000000000 wei",
+ "231211221": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 1000000000000000 wei + 21000 gas ร 11958113760 wei"
+ }
+ }
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool_status.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool_status.md
new file mode 100644
index 0000000..0c44863
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/mempool/txpool_status.md
@@ -0,0 +1,64 @@
+# txpool\_status
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const status = await tatum.rpc.txPoolStatus()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_status` method returns statistics about the current state of the transaction pool. The transaction pool is a queue of pending transactions waiting to be included in the next block by miners.
+
+This method can be useful for monitoring the health of the network and analyzing the behavior of the miners. It can also be used to estimate the time it will take for a transaction to be processed, as well as to determine the gas price necessary to ensure prompt inclusion of a transaction in the next block.
+
+### Parameters
+
+This method does not take any parameters.
+
+### Return Object
+
+The `txpool_status` method returns an object with the following fields:
+
+* **`pending`**: Number of pending transactions in the pool
+* **`queued`**: Number of queued transactions in the pool
+
+### Example Request
+
+```json
+{
+ "jsonrpc":"2.0",
+ "method":"txpool_status",
+ "params":[],
+ "id":1
+}
+```
+
+### Example Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": 4,
+ "queued": 10
+ }
+}
+```
+
+In this example response, there are currently 4 pending transactions and 10 queued transactions waiting to be processed by miners.
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/README.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/README.md
new file mode 100644
index 0000000..bd96ae8
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/README.md
@@ -0,0 +1,2 @@
+# Network/Client information
+
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/eth_chainid.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/eth_chainid.md
new file mode 100644
index 0000000..64e7d8b
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/eth_chainid.md
@@ -0,0 +1,61 @@
+# eth\_chainId
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const id = await tatum.rpc.chainId()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_chainId` method is an JSON-RPC method that allows developers to retrieve the currently configured chain ID of the network they are connected to. The chain ID is a unique identifier for different networks, such as mainnet or various testnets.
+
+This method is particularly useful when building applications that interact with multiple networks or need to verify the network to prevent replay attacks. By checking the chain ID, an application can ensure it is interacting with the intended network.
+
+### Parameters
+
+The `eth_chainId` method does not have any input parameters.
+
+### Return Object
+
+The return object contains a single field:
+
+* **`chainId`**: The hexadecimal string representation of the chain ID.
+
+### Example Request and Response
+
+JSON-RPC request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_chainId",
+ "params": []
+}
+```
+
+JSON-RPC response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0xe"
+}
+```
+
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/web3_clientversion.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/web3_clientversion.md
new file mode 100644
index 0000000..ac2cea8
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-client-information/web3_clientversion.md
@@ -0,0 +1,63 @@
+# web3\_clientVersion
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const version = await tatum.rpc.clientVersion()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`web3_clientVersion` is a method of the JSON-RPC API that allows the client to retrieve the current version of the client software being used by the node.
+
+This method is read-only and does not require authentication. The `web3_clientVersion` method can be used by developers to confirm the version of the client software they are using and ensure that it is compatible with their application.
+
+### Parameters
+
+This method has no parameters. It only retrieves the current version of the client software.
+
+### Return Object
+
+The `web3_clientVersion` method returns a string representing the version of the client software being used. The string includes the client name, version number, and build information.
+
+* `String` - Version string of the client software being used.
+
+### Example Request
+
+#### JSON Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "web3_clientVersion",
+ "params": [],
+ "id": 1
+}
+```
+
+### Example Response
+
+#### JSON Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 67,
+ "result": "v0.9.0"
+}
+```
+
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/README.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/README.md
new file mode 100644
index 0000000..cbe8e09
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/README.md
@@ -0,0 +1,2 @@
+# Network state
+
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_blocknumber.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_blocknumber.md
new file mode 100644
index 0000000..4acfc0a
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_blocknumber.md
@@ -0,0 +1,69 @@
+# eth\_blockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const latestBlock = await tatum.rpc.blockNumber()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_blockNumber` method returns the number of the most recent block on the blockchain. This method is commonly used to track the current state of the network, monitor for new blocks, or fetch historical data.
+
+Use cases for `eth_blockNumber` include:
+
+* Synchronising a local copy of the blockchain with the network
+* Checking the status of a transaction by comparing its block number to the current block number
+* Determining the current network state for smart contract interactions\
+
+
+### Parameters
+
+The `eth_blockNumber` method does not require any parameters.
+
+### Return Object
+
+The `eth_blockNumber` method returns a single field:
+
+* **`blockNumber`**: The number of the most recent block on the blockchain. The value is returned as a hexadecimal string.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_blockNumber",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4b7" // 1207
+}
+```
+
+In this example, the most recent block number is 1207 (`0x4b7` in hexadecimal notation).
+
+Please note that while this document provides a comprehensive description of the `eth_blockNumber` RPC method, other methods may be needed to obtain full transaction details or perform more complex tasks. Refer to the [Ethereum JSON-RPC documentation](https://eth.wiki/json-rpc/API) for more information.
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getbalance.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getbalance.md
new file mode 100644
index 0000000..5ae3e72
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getbalance.md
@@ -0,0 +1,108 @@
+# eth\_getBalance
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const balance = await tatum.rpc.getBalance('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+// dotnet add ${your_project} package Tatum
+
+var tatumSdk = await TatumSdk.InitAsync();
+
+var rpcCall = new JsonRpcCall
+{
+ Id = "1",
+ JsonRpc = "2.0",
+ Method = "eth_getBalance",
+ Params = new object[]
+ {
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ }
+};
+
+var result = await tatumSdk.Rpc.Flare.Call(rpcCall);
+```
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBalance` method is an JSON-RPC method that allows you to retrieve the balance of a specified address. This method can be used to query the balance of any address, whether it is a contract or an externally owned account (EOA). A common use case for this method is to display the current balance of a user's account in a wallet application or a decentralized application (DApp).
+
+### Parameters
+
+The method requires two parameters:
+
+1. **`address`** (required): The address of the account or contract whose balance you want to query.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`blockParameter`** (optional): The block number or block identifier to specify the point in time for which you want to query the balance.
+ * Example: `"latest"` or `"0x1"`
+
+#### Transaction Details
+
+For the purpose of this documentation, we'll also describe the `transactions` field of a full transaction object. The `eth_getBalance` method does not return transaction details, but we provide this information for completeness.
+
+A full transaction object includes the following fields:
+
+* **`hash`**: The transaction hash.
+* **`nonce`**: The number of transactions made by the sender prior to this one.
+* **`blockHash`**: The hash of the block in which the transaction was included.
+* **`blockNumber`**: The block number in which the transaction was included.
+* **`transactionIndex`**: The index of the transaction in the block.
+* **`from`**: The sender's address.
+* **`to`**: The recipient's address (or `null` for contract creation transactions).
+* **`value`**: The value transferred, in wei.
+* **`gasPrice`**: The gas price provided by the sender, in wei.
+* **`gas`**: The maximum gas allowed for the transaction.
+* **`input`**: The data sent with the transaction (typically for contract interaction).
+* **`v`**, **`r`**, **`s`**: The raw signature values of the transaction.
+
+### Return Object
+
+The method returns a single field:
+
+* `result`: The Flare balance of the specified address in wei, as a hexadecimal string.
+ * Example: `"0x1a2e1a"`, which corresponds to `1,726,666` wei.
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBalance",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1a2e1a"
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblockbyhash.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblockbyhash.md
new file mode 100644
index 0000000..ab25d65
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblockbyhash.md
@@ -0,0 +1,137 @@
+# eth\_getBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const block = await tatum.rpc.getBlockByHash('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByHash` is an JSON-RPC method that allows developers to query a specific block in the blockchain by its block hash. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+### Parameters
+
+The `eth_getBlockByHash` method accepts two parameters:
+
+1. **`blockHash`**: The hash of the block you want to retrieve information about.
+ * Type: `String`
+ * Example: `"0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b"`
+2. **`fullTransactionDetails`**: A boolean value indicating whether to return full transaction details or just transaction hashes.
+ * Type: `Boolean`
+ * Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByHash",
+ "params": ["0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b", true],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblockbynumber.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblockbynumber.md
new file mode 100644
index 0000000..c7e60d6
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblockbynumber.md
@@ -0,0 +1,134 @@
+# eth\_getBlockByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init<AvalancheC>({network: Network.AVALANCHE_C})
+
+const block = await tatum.rpc.getBlockByNumber('latest', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByNumber` is an JSON-RPC method that allows developers to query a specific block in the blockchain by its block number. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+### Parameters
+
+There are two required parameters for this method:
+
+1. **`blockNumber`** - The block number of the block to be retrieved. This can be a hexadecimal string or one of the predefined aliases: `"earliest"`, `"latest"`, or `"pending"`.
+
+ Example: `"0x1b4"`
+2. **`returnFullTransactionObjects`** - A boolean value that determines whether the returned block contains complete transaction objects (`true`) or only transaction hashes (`false`).
+
+ Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByNumber",
+ "params": ["latest", true]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
new file mode 100644
index 0000000..2ec30f0
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
@@ -0,0 +1,68 @@
+# eth\_getBlockTransactionCountByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const response = await tatum.rpc.getBlockTransactionCountByHash('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockTransactionCountByHash` is a RPC method used to fetch the number of transactions in a block by the block's hash. It is useful when you want to know the total number of transactions included in a specific block and don't want to retrieve the entire block data. This method can be used in various scenarios, such as monitoring the network activity or estimating transaction confirmation times.
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`blockHash`**: The hash of the target block for which the transaction count will be retrieved. It should be a valid 32-byte hex string.
+
+Example of the parameter:
+
+* `blockHash`: `"0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"`
+
+### Return
+
+The method returns a single value:
+
+* `transactionCount`: The total number of transactions included in the specified block. It is returned as a hexadecimal value.
+
+### Examples
+
+#### JSON-RPC request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockTransactionCountByHash",
+ "params": [
+ "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
+ ]
+}
+```
+
+#### JSON-RPC response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0xa"
+}
+```
+
+In this example, the block with the hash `"0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"` has a total of 10 transactions (indicated by the hexadecimal value `"0xa"`).
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
new file mode 100644
index 0000000..0c5c772
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
@@ -0,0 +1,63 @@
+# eth\_getBlockTransactionCountByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const response = await tatum.rpc.getBlockTransactionCountByNumber('0xAD7C5E')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBlockTransactionCountByNumber` JSON-RPC method allows you to retrieve the number of transactions in a specified block. This method is particularly useful when you need to analyze the transaction activity of a specific block. You can use it to gain insights into network usage, analyze the impact of specific events on the network, or monitor transaction congestion in certain blocks.
+
+### Parameters
+
+1. **`blockNumber`**: The block number for which the transaction count should be retrieved. It should be a hex-encoded value representing the block number.
+ * Example: `"0x1b4"` (block number 436)
+
+### Return Object
+
+The return object is a hex-encoded value representing the number of transactions in the specified block.
+
+* Example: `"0xa"` (10 transactions)
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBlockTransactionCountByNumber",
+ "params": ["0x1b4"]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0xa"
+}
+```
+
+
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getcode.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getcode.md
new file mode 100644
index 0000000..efa0d0f
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getcode.md
@@ -0,0 +1,76 @@
+# eth\_getCode
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const code = await tatum.rpc.getCode('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getCode` method is part of the JSON-RPC API, which allows users to interact with the blockchain. This method is specifically used to retrieve the contract code (bytecode) of an account at a specific block number. It is helpful when developers need to examine the bytecode of a deployed contract or validate that the contract code on the blockchain matches the intended code.
+
+Use cases for this method could include:
+
+* Debugging a smart contract
+* Verifying the integrity of a deployed contract
+* Analyzing contract bytecode for security vulnerabilities
+
+### Parameters
+
+The `eth_getCode` method accepts two parameters:
+
+1. **`address`** (string): The address of the contract whose bytecode you want to retrieve. This should be a 20-byte address, formatted as a hex string with a `0x` prefix.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`block`** (string): The block number at which you want to retrieve the contract code. This can be specified as a hex string or one of the following special keywords:
+ * `"earliest"`: The first block in the blockchain
+ * `"latest"`: The most recent block in the blockchain
+ * `"pending"`: The upcoming block that is being mined
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The `eth_getCode` method returns a string representing the contract bytecode. The returned value is a hex string with a `0x` prefix.
+
+* If the account has contract code, the returned string will contain the bytecode.
+* If the account is not a contract or does not exist, the returned string will be `0x`.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getCode",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x606060...code_here...3839"
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getlogs.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getlogs.md
new file mode 100644
index 0000000..c751ca3
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getlogs.md
@@ -0,0 +1,111 @@
+# eth\_getLogs
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const logs = await tatum.rpc.getLogs({ address : '0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getLogs` method is an JSON-RPC method that allows developers to query logs generated by the network, specifically event logs emitted by smart contracts. These logs are an essential part of the ecosystem as they provide a way for developers to monitor contract events and track contract state changes.
+
+This method is particularly useful when building decentralized applications (dApps) that rely on events emitted by smart contracts, as it enables developers to retrieve logs based on specific filter criteria. By using `eth_getLogs`, developers can efficiently track and react to events happening on the blockchain.
+
+### Parameters
+
+The `eth_getLogs` method takes a single input parameter: an object containing the filter criteria. The filter object can have the following fields:
+
+* **`fromBlock`**: (optional) The starting block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"fromBlock": "0x1"`
+* **`toBlock`**: (optional) The ending block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"toBlock": "0x2"`
+* **`address`**: (optional) The address or list of addresses of the contracts to filter logs from. Can be a single address or an array of addresses.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`topics`**: (optional) An array of up to four 32-byte topics. Topics are order-dependent, and each topic can be an array of topic hashes or `null`.
+ * Example: `"topics": ["0x123..."]`
+* **`blockhash`**: (optional) The block hash to filter logs from. If provided, `fromBlock` and `toBlock` are ignored.
+ * Example: `"blockhash": "0xc6ef9..."`
+
+In addition to the above fields, the `transactions` field in the filter object can be specified to include full transaction details instead of just transaction hashes. This is useful when you need more information about the transactions in which the events were emitted.
+
+### Return Object
+
+The `eth_getLogs` method returns an array of log objects. Each log object contains the following fields:
+
+* **`removed`**: A boolean indicating whether the log was removed due to a chain reorganization.
+ * Example: `"removed": false`
+* **`logIndex`**: The log index position in the block.
+ * Example: `"logIndex": "0x1"`
+* **`transactionIndex`**: The transaction index position in the block.
+ * Example: `"transactionIndex": "0x0"`
+* **`transactionHash`**: The hash of the transaction that emitted the log.
+ * Example: `"transactionHash": "0x88eef..."`
+* **`blockHash`**: The hash of the block containing the log.
+ * Example: `"blockHash": "0xc6ef9..."`
+* **`blockNumber`**: The block number containing the log.
+ * Example: `"blockNumber": "0x1"`
+* **`address`**: The address of the contract that emitted the log.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`data`**: The data associated with the log.
+ * Example: `"data":"0x0000000000000000000000000000000000000000000000000000000000000020"`
+* **`topics`**: An array of topics (order-dependent) associated with the log.
+ * Example: `"topics": ["0x123..."]`
+
+## JSON-RPC Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getLogs",
+ "params": [
+ {
+ "fromBlock": "0x1",
+ "toBlock": "0x2",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "removed": false,
+ "logIndex": "0x1",
+ "transactionIndex": "0x0",
+ "transactionHash": "0x88eef...",
+ "blockHash": "0xc6ef9...",
+ "blockNumber": "0x1",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "data": "0x0000000000000000000000000000000000000000000000000000000000000020",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+This documentation provides a comprehensive overview of the `eth_getLogs` JSON-RPC method, its parameters, return objects, and JSON-RPC examples. By using this method, developers can effectively query logs generated by the network and use the retrieved data to track and react to events happening on the blockchain.
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getproof.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getproof.md
new file mode 100644
index 0000000..03aca50
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getproof.md
@@ -0,0 +1,107 @@
+# eth\_getProof
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const result = await tatum.rpc.getProof("0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+ "latest")
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getProof` is a JSON-RPC method that retrieves the Merkle-Patricia proof for an account, storage key-value pairs, and account transaction count. It allows developers to verify the state of an account or storage value at a specific block without needing the entire state trie. This method is particularly useful for light clients or off-chain applications that require proof of an account's state or specific storage values.
+
+### Parameters
+
+1. **`address`** - `Data`, 20 Bytes
+ * The address of the account.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`keys`** - `Array` of `Data`
+ * An array of storage keys for which the proof should be generated.
+ * Example: `["0x0000000000000000000000000000000000000000000000000000000000000000"]`
+3. **`blockNumber`** - `Quantity` or `String`
+ * The block number for which the proof should be generated.
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+1. **`accountProof`** - `Array` of `Data`
+ * The serialized Merkle-Patricia proof for the account.
+2. **`balance`** - `Quantity`
+ * The balance of the account at the specified block.
+3. **`codeHash`** - `Data`, 32 Bytes
+ * The hash of the code for the account at the specified block.
+4. **`nonce`** - `Quantity`
+ * The transaction count of the account at the specified block.
+5. **`storageProof`** - `Array` of `Object`
+ * An array of storage proof objects, one for each requested key, containing the following fields:
+ * `key` - `Data`, 32 Bytes: The storage key.
+ * `value` - `Quantity`: The storage value.
+ * `proof` - `Array` of `Data`: The serialized Merkle-Patricia proof for the key-value pair.
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getProof",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ [
+ "0x0000000000000000000000000000000000000000000000000000000000000000"
+ ],
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": {
+ "accountProof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ],
+ "balance": "0xde0b6b3a7640000",
+ "codeHash": "0x...",
+ "nonce": "0x1",
+ "storageProof": [
+ {
+ "key": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "value": "0xde0b6b3a7640000",
+ "proof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ]
+ }
+ ]
+ }
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getstorageat.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getstorageat.md
new file mode 100644
index 0000000..af692fc
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getstorageat.md
@@ -0,0 +1,69 @@
+# eth\_getStorageAt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const response = await tatum.rpc.getStorageAt('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', '0x0')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getStorageAt` is an JSON-RPC method that allows you to query the storage value of a contract at a given position. It can be used to inspect the internal state of a smart contract. This method is particularly useful for developers, auditors, and analysts who want to examine contract storage values for various purposes, such as debugging, verifying contract behavior, or analyzing data.
+
+### Parameters
+
+`eth_getStorageAt` accepts three parameters:
+
+1. **`address`**: The address of the contract you want to query.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`position`**: The storage position (slot) you want to query.
+ * Example: `"0x0"`
+3. **`blockParameter`**: The block number, block hash, or one of the string literals (`"earliest"`, `"latest"` or `"pending"`), representing the point in the blockchain to query the storage value.
+ * Example: `"latest"`
+
+### Return Object
+
+The return object is a single string value, representing the storage value at the given position in the contract.
+
+* `result`: The storage value in a 32-byte (64 character) hexadecimal format.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getStorageAt",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "0x0",
+ "latest"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x0000000000000000000000000000000000000000000000000000000000000123"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
new file mode 100644
index 0000000..f58d911
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
@@ -0,0 +1,102 @@
+# eth\_getTransactionByBlockHashAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const tx = await tatum.rpc.getTransactionByBlockHashAndIndex('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d', 0)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockHash` (required): The hash of the block containing the transaction.
+ * Example: `"0x9a9a2a0d69b4ff48f7a2a8a26d135e1dbcbd3c3be3e8a3c90de0bcb104e4c4b4"`
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a hexadecimal value.
+ * Example: `"0x0"`
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockHashAndIndex",
+ "params": [
+ "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "0x0"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "from": "0x37a53636ee68f59d9346aabcfc0d36011d9d5b35",
+ "gas": "0x5b8d80",
+ "gasPrice": "0x59682f0a",
+ "maxFeePerGas": "0x59682f10",
+ "maxPriorityFeePerGas": "0x59682f00",
+ "hash": "0x40a0f78e346d15b05efa1861149e5999ea48197dcf104d69160d45b08b7a5118",
+ "input": "0xb1dc65a4000129d4314ec8c4bafb6468cc9d3c21de025fa54002558c9f76aec833406ab600000000000000000000000000000000000000000000000000000000001ccc01f18333a24416e0a0be9cdb78505c9c3c27fa42bccdbe6456cd6c1fc81bee7c0e00000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000022000000000000000000000000000000000000000000000000000000000000003a001000000010100010100010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000003d150000000000000000000000000000000000000000000000000000000000003d17325325668a08b50a9587fd4605ce02dbc5ccefc4883a41b485ff4dc4a4f86f1e0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000a8690000000000000000000000000000000000000000000000000000009d29229e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ba6547e7b549a1f180c5ad4f2e2e7104fecb8373482f3de6574ecbeefdc9be9dfd9f1934768a23584f1508adad8a7bbfbe445a27bed9f1d4538d4e4c9e458b0c5274b6f714f5aee9a8d56aeb8957b6da6b8914e445a46dcd349737b2eb7d72132e41926d07355de577b13e6ec8e55eaaf628b333197a8d1292bed1c375e891e1da1d519aabbebcc6d299b575b7bef506e2db9493de6f0cfdb0436a81597eb155edc63a8ea655a9b405a0c41c923b1734d78b5d9812f36a602ace3d8c5b22beb9519e406f32de9768e518f2b253a95364a9a2838ba5023c52d503fe8fa811c8803399679a19513671b13d4040e46be74e152d39be4f68bfecaa57d27965ba724a09464734faf7230b19e04f4aa581f10066884e2f402af36f0cdbf08de95e190f4f31fd3b718c1317b65fba9e7ea45ef6180e4861839c6395c814214ee8d56b28ba19f47b6b80f43045635432971b30f2bfb3a26a53ca502bf21fa598c5ddb934b000000000000000000000000000000000000000000000000000000000000000b3ab737e679aefe131ad3efc850fd2c50b316aabcdaa4368587d9606df84b3590541698c7c5538111187964e1b3f39fa033033bb7cab30275ea11b912089663ec43243ff37fa9d2cce04dfce25738c3a484d42f8d8a2c6be226627606f75788ee0e777481b5bd100d00d118bddd18e8726f7a54333b6228f57fa3237799079eb56e6e0ac0cb0f334d23f7284e2dcb2f463d8104fc198389e42a9d1bad1dcfe983115d3d85474db611a6e82b2f61b8d93efa77bc039bd5b3b0f02a7fc587d4a12a0daf256c21ecb9664e6c90c2bfb72a753ff008d3306f7cd4c823df6685fc4cba1514ed132d6367a8f99fba241fc6ef6917f5279ebfdd3e05a296e5c4d77a5463037d7c8180d0644d7e90123918c30fca011d710201ceabcae277924f32ff6b9d0e4d285eb59b4b56d3af8d4b2ab1a39ec2d4324e49deea661cbd43f21cbdc76a10a14055ecdd3251a5860c3bb02bcc1f21da5564fc05adbac70c7565fb5f44b8",
+ "nonce": "0xec0",
+ "to": "0x8febc74c26129c8d7e60288c6dccc75eb494aa3c",
+ "transactionIndex": "0x0",
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0xccf7b8fd2d63782e651f4d9650c0ed1a430060fd947d97b6504876f8ea16b357",
+ "s": "0x50c56d90105b1b8aa475c9500137e9b7c4f0a331fee076bc395a695dc471dc05"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
new file mode 100644
index 0000000..6df90e1
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
@@ -0,0 +1,102 @@
+# eth\_getTransactionByBlockNumberAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const tx = await tatum.rpc.getTransactionByBlockNumberAndIndex('0xAD7C5E', 0)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockNumber` (required): The hash of the block containing the transaction.
+ * Example: `"0x316624"`
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a hexadecimal value.
+ * Example: `"0x0"`
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockNumberAndIndex",
+ "params": [
+ "0x316624",
+ "0x0"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "from": "0x37a53636ee68f59d9346aabcfc0d36011d9d5b35",
+ "gas": "0x5b8d80",
+ "gasPrice": "0x59682f0a",
+ "maxFeePerGas": "0x59682f10",
+ "maxPriorityFeePerGas": "0x59682f00",
+ "hash": "0x40a0f78e346d15b05efa1861149e5999ea48197dcf104d69160d45b08b7a5118",
+ "input": "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",
+ "nonce": "0xec0",
+ "to": "0x8febc74c26129c8d7e60288c6dccc75eb494aa3c",
+ "transactionIndex": "0x0",
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0xccf7b8fd2d63782e651f4d9650c0ed1a430060fd947d97b6504876f8ea16b357",
+ "s": "0x50c56d90105b1b8aa475c9500137e9b7c4f0a331fee076bc395a695dc471dc05"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionbyhash.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionbyhash.md
new file mode 100644
index 0000000..e870666
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionbyhash.md
@@ -0,0 +1,92 @@
+# eth\_getTransactionByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const tx = await tatum.rpc.getTransactionByHash('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByHash` is an JSON-RPC method that allows you to query transaction details based on its hash. This method is useful when you want to retrieve information about a specific transaction, such as its sender, receiver, value, and more. Common use cases include tracking transaction status, monitoring incoming transactions, or analyzing historical transaction data.
+
+### Parameters
+
+The `eth_getTransactionByHash` method takes one parameter:
+
+* **`transactionHash`**: The hash of the transaction you want to retrieve. This should be a 32-byte hash string with a `0x` prefix.
+ * Example: `"0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"`
+
+### Return Object
+
+The method returns a transaction object with the following fields:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getTransactionByHash",
+ "params": ["0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"],
+ "id": 1
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "from": "0x53e8577c4347c365e4e0da5b57a589cb6f2ab848",
+ "gas": "0x3c524",
+ "gasPrice": "0x306dc421e",
+ "hash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "input": "0x50bb4e7f00000000000000000000000074b4551c177592a908c6ab9ce671bfe8c1b5bd40000000000000000000000000000000000000000000000000000056b990e70e000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000006068747470733a2f2f6574682d6d61696e6e65742e672e616c6368656d792e636f6d2f76322f72646f704c505054424a31536f786b2d555179306b7464676f4b45326146637a2f6765744e4654732f3f6f776e65723d766974616c696b2e657468",
+ "nonce": "0xc97",
+ "to": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "transactionIndex": "0x4",
+ "value": "0x0",
+ "type": "0x0",
+ "chainId": "0xaa36a7",
+ "v": "0x1546d71",
+ "r": "0xf89098451217613aa4abbb3f8988e75e20ae948d07bf8b26c472bc9bda50c9d9",
+ "s": "0x15cfb5b34bcb23730aeadc28df3b66fa9cf28103ffc8b557d76f0c1df078028e"
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactioncount.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactioncount.md
new file mode 100644
index 0000000..31e95cd
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactioncount.md
@@ -0,0 +1,74 @@
+# eth\_getTransactionCount
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const result = await tatum.rpc.getTransactionCount('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', 'pending')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getTransactionCount` method is an JSON-RPC method that retrieves the number of transactions sent from a given address. It is a useful method for developers who need to keep track of an account's nonce value to avoid transaction collisions or incorrect order of execution. The nonce value is essential for ensuring transaction uniqueness and preventing replay attacks.
+
+Use cases for this method include:
+
+* Determining the nonce value for a new transaction to be sent from a specific address
+* Monitoring the number of transactions sent by an address to observe its activity
+* Troubleshooting transaction issues and verifying if a transaction was submitted successfully
+
+### Parameters
+
+The `eth_getTransactionCount` method accepts two parameters:
+
+1. **`address`** - The address whose transaction count will be retrieved.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`blockParameter`** - A string indicating the block number or block state to consider when retrieving the transaction count.
+ * Possible values: `"earliest"`, `"latest"`, `"pending"`, or a specific block number in hexadecimal format
+ * Example: `"latest"`
+
+### Return Object
+
+The method returns a single value:
+
+* **`transactionCount`** - A hexadecimal representation of the number of transactions sent from the specified address.
+ * Example: `"0x1e"`
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionCount",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1e"
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionreceipt.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionreceipt.md
new file mode 100644
index 0000000..1e1119c
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_gettransactionreceipt.md
@@ -0,0 +1,129 @@
+# eth\_getTransactionReceipt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const tx = await tatum.rpc.getTransactionReceipt('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+// dotnet add ${your_project} package Tatum
+
+var tatumSdk = await TatumSdk.InitAsync();
+
+var rpcCall = new JsonRpcCall
+{
+ Id = "1",
+ JsonRpc = "2.0",
+ Method = "eth_getTransactionReceipt",
+ Params = new object[]
+ {
+ "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"
+ }
+};
+
+var result = await tatumSdk.Rpc.AvalancheC.Call(rpcCall);
+```
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionReceipt` is an JSON-RPC method that retrieves the transaction receipt of a given transaction hash. This method is particularly useful when you need to obtain detailed information about a transaction's execution, such as its status (success or failure), gas usage, and logs (events). Common use cases include checking the status of a transaction after it has been mined or inspecting the events emitted by a smart contract during a specific transaction.
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`transactionHash`**: The hash of the transaction for which you want to obtain the receipt.
+ * Example: `"0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+* **`transactionHash`**: The hash of the transaction.
+* **`transactionIndex`**: The transaction's index position in the block.
+* **`blockHash`**: The hash of the block where this transaction was mined.
+* **`blockNumber`**: The block number where this transaction was mined.
+* **`from`**: The address of the sender.
+* **`to`**: The address of the receiver. `null` when it's a contract creation transaction.
+* **`cumulativeGasUsed`**: The total amount of gas used when this transaction was executed in the block.
+* **`gasUsed`**: The amount of gas used by this specific transaction alone.
+* **`contractAddress`**: The address of the contract created, if the transaction was a contract creation. Otherwise, `null`.
+* **`logs`**: An array of log objects, which were emitted during the transaction.
+* **`logsBloom`**: A 256-byte bloom filter, which is a compressed representation of the logs emitted during the transaction.
+* **`status`**: The status of the transaction's execution. `"0x1"` indicates success, while `"0x0"` indicates failure.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionReceipt",
+ "params": [
+ "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "contractAddress": null,
+ "cumulativeGasUsed": "0x7ad81",
+ "effectiveGasPrice": "0x306dc421e",
+ "from": "0x53e8577c4347c365e4e0da5b57a589cb6f2ab848",
+ "gasUsed": "0x3c518",
+ "logs": [
+ {
+ "address": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "topics": [
+ "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "0x00000000000000000000000074b4551c177592a908c6ab9ce671bfe8c1b5bd40",
+ "0x000000000000000000000000000000000000000000000000000056b990e70e00"
+ ],
+ "data": "0x",
+ "blockNumber": "0x316624",
+ "transactionHash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "transactionIndex": "0x4",
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "logIndex": "0x3",
+ "removed": false
+ }
+ ],
+ "logsBloom": "0x00000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000020000010000000000000800000000000000000000000010000040000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000100000000000000000000000000000000002000000200000000000100000000000800000000000000000000020000000000000000000000200000000000000000000000000000000000000000000",
+ "status": "0x1",
+ "to": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "transactionHash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "transactionIndex": "0x4",
+ "type": "0x0"
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getunclecountbyblockhash.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
new file mode 100644
index 0000000..5b960d2
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
@@ -0,0 +1,70 @@
+# eth\_getUncleCountByBlockHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const result = await tatum.rpc.getUncleCountByBlockHash('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the network and to analyze the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralization of the network. The inclusion of uncles helps prevent centralization and ensures the mining process remains competitive.
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockHash`: The hash of the block for which you want to get the uncle count.
+ * Example value: `"0x3a3e528dcd6e05a614c9241b0a9296db961fa6a92e05af9f6c0d7d2f6bc92f7a"`
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockHash` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockHash",
+ "params": [
+ "0x3a3e528dcd6e05a614c9241b0a9296db961fa6a92e05af9f6c0d7d2f6bc92f7a"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x1"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
new file mode 100644
index 0000000..693371a
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
@@ -0,0 +1,71 @@
+# eth\_getUncleCountByBlockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const result = await tatum.rpc.getUncleCountByBlockNumber('0xAD7C5E')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the network and to analyze the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralization of the network. The inclusion of uncles helps prevent centralization and ensures the mining process remains competitive.
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockNumber`: The number of the block for which you want to get the uncle count.
+ * Example value: `"0x12345"`
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockNumber` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockNumber",
+ "params": [
+ "0x12345"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x1"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/README.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/README.md
new file mode 100644
index 0000000..1b1ccbc
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/README.md
@@ -0,0 +1,2 @@
+# Transaction
+
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_estimategas.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_estimategas.md
new file mode 100644
index 0000000..fe928d6
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_estimategas.md
@@ -0,0 +1,92 @@
+# eth\_estimateGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const estimate = await tatum.rpc.estimateGas({
+ "from": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ "to": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e87",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060"
+ })
+
+ tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_estimateGas` is an JSON-RPC method that estimates the amount of gas required to execute a given transaction. This method can be used to determine the gas cost before sending a transaction, allowing developers to better predict the gas fees and avoid issues like out-of-gas errors.
+
+Use cases for `eth_estimateGas` include:
+
+* Estimating gas costs for contract deployments
+* Estimating gas costs for contract function calls
+* Estimating gas costs for standard transfers
+
+### Parameters
+
+The `eth_estimateGas` method takes a single parameter, an object representing the transaction details. The fields in the transaction object include:
+
+* **`from`** (optional, string): The address that the transaction is sent from.
+ * Example: `"from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`to`** (optional, string): The address the transaction is sent to.
+ * Example: `"to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`gas`** (optional, string): The maximum amount of gas provided for the transaction.
+ * Example: `"gas": "0x76c0"`
+* **`gasPrice`** (optional, string): The price of gas in wei.
+ * Example: `"gasPrice": "0x9184e72a000"`
+* **`value`** (optional, string): The amount of ZEN to send in the transaction, in wei.
+ * Example: `"value": "0xde0b6b3a7640000"`
+* **`data`** (optional, string): The data payload of the transaction, typically used for contract function calls or contract deployment.
+ * Example: `"data": "0x606060..."`
+* **`nonce`** (optional, string): The transaction count of the `from` address.
+ * Example: `"nonce": "0x1"`
+
+### Return Object
+
+The return value of the `eth_estimateGas` method is a single field:
+
+* `gasEstimate` (string): The estimated gas cost for the transaction, represented as a hexadecimal string.
+ * Example: `"0x5208"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_estimateGas",
+ "params": [
+ {
+ "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060..."
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x5208"
+}
+```
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_gasprice.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_gasprice.md
new file mode 100644
index 0000000..0578d30
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_gasprice.md
@@ -0,0 +1,60 @@
+# eth\_gasPrice
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const gasPrice = await tatum.rpc.gasPrice()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_gasPrice` method is an JSON-RPC method used to estimate the average gas price required for transactions in the network. This method provides a suggestion for the gas price to be used in a transaction to increase the likelihood of it being mined and included in a block in a reasonable amount of time. The `eth_gasPrice` method is particularly useful for developers and users who want to create and send transactions, as it helps them estimate the appropriate gas price to ensure timely processing.
+
+### Parameters
+
+The `eth_gasPrice` method does not require any parameters.
+
+### Return Value
+
+The `eth_gasPrice` method returns a single value as a hexadecimal string:
+
+* `gasPrice`: The estimated average gas price in wei. Example: `"0x4a817c800"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_gasPrice",
+ "params": []
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4a817c800"
+}
+```
+
+By using the `eth_gasPrice` method, developers and users can estimate the appropriate gas price for their transactions, improving the overall user experience and ensuring that their transactions are processed in a timely manner.
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_maxpriorityfeepergas.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
new file mode 100644
index 0000000..f46fe22
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
@@ -0,0 +1,62 @@
+# eth\_maxPriorityFeePerGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const gasPrice = await tatum.rpc.maxPriorityFeePerGas()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_maxPriorityFeePerGas` RPC method is used to retrieve the maximum priority fee per gas set by the user for a transaction. This method can be used to determine the maximum fee that can be paid for a transaction to be included in a block quickly.
+
+### Use case
+
+This method is particularly useful when the user wants to ensure that a transaction is processed quickly, even in a congested network where transaction fees may fluctuate rapidly. By setting a high maximum priority fee per gas, the user can ensure that the transaction is processed as quickly as possible.
+
+### Parameters
+
+`None.`
+
+## Return Object
+
+* `maxPriorityFeePerGas` - The maximum priority fee per gas the user is willing to pay, in wei.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_maxPriorityFeePerGas",
+ "params": [],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x3b9aca00"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_sendrawtransaction.md b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_sendrawtransaction.md
new file mode 100644
index 0000000..7277792
--- /dev/null
+++ b/docs/rpc/evm-blockchains/avalanche-rpc-documentation/transaction/eth_sendrawtransaction.md
@@ -0,0 +1,62 @@
+# eth\_sendRawTransaction
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, AvalancheC, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.AVALANCHE_C})
+
+const gasPrice = await tatum.rpc.sendRawTransaction('0x0000.......')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_sendRawTransaction` RPC method is used to send a signed and serialized transaction to the network. This method is particularly useful when you want to have full control over the signing process, e.g., when using hardware wallets, cold storage, or custom signing libraries. It can be utilized in various use cases, such as transferring, interacting with smart contracts, or deploying new contracts.
+
+### Parameters
+
+The method accepts a single parameter:
+
+* **`data`**: The signed and serialized transaction data as a hexadecimal string.
+
+### Return Value
+
+The method returns a single value:
+
+* `transactionHash`: The hash of the submitted transaction as a hexadecimal string, e.g., `"0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"`.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_sendRawTransaction",
+ "params": [
+ "0xf86d8201...94a7bc"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/README.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/README.md
new file mode 100644
index 0000000..e39b70a
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/README.md
@@ -0,0 +1,3 @@
+# BSC RPC documentation
+
+JSON-RPC endpoints refers to the network location where a program could transfer its RPC requests to access server data. Once you connect a decentralized application to an RPC endpoint, you can access the functionalities of different operations, which could enable real-time usage of blockchain data. BNB Chain provides several RPC endpoints for connectinto both its Minent and Testnet. In this section, we list the JSON-RPC endpoints that can be used for connecting to BNB Smart Chain.
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/README.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/README.md
new file mode 100644
index 0000000..1fb947d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/README.md
@@ -0,0 +1,2 @@
+# Archival information
+
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_storagerangeat.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_storagerangeat.md
new file mode 100644
index 0000000..9a383e0
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_storagerangeat.md
@@ -0,0 +1,84 @@
+# debug\_storageRangeAt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const result = await tatum.rpc.debugStorageRangeAt(
+'0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d',
+1, '0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', '0x0', '0x64'
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_storageRangeAt` is an RPC method that allows you to retrieve the contract storage range for a given block and address. This can be useful for developers and auditors who want to inspect the storage state of a specific contract at a particular point in time. This method can also help in debugging and identifying potential issues with contract storage, as well as understanding how storage evolves as transactions are executed.
+
+### Parameters
+
+The `debug_storageRangeAt` method accepts the following parameters:
+
+* `blockHash`: The block hash for which the storage range should be retrieved. Example: `"0x3c4523b7e8c21e3d68f1c3af3d18e8a87c0d43e35b2c1b7f8f4e87e4d4db9c82"`
+* `txIndex`: The transaction index within the specified block. Example: `1`
+* `address`: The contract address for which the storage range should be retrieved. Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* `begin`: The beginning of the storage range. Example: `"0x0"`
+* `end`: The end of the storage range. Example: `"0x64"` (inclusive)
+
+### Return Object
+
+The `debug_storageRangeAt` method returns an object with the following fields:
+
+* `storage`: An object that contains key-value pairs representing the contract storage, where the key is the storage slot and the value is the stored data. Example: `"0x00..01": "0x00..01"`
+* `nextKey`: A key indicating the next storage slot if the requested range is too large, otherwise `null`. Example: `"0x00..02"` or `null`
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "debug_storageRangeAt",
+ "params": [
+ "0x3c4523b7e8c21e3d68f1c3af3d18e8a87c0d43e35b2c1b7f8f4e87e4d4db9c82",
+ 1,
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "0x0",
+ "0x64"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000002"
+ },
+ "nextKey": "0x0000000000000000000000000000000000000000000000000000000000000065"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_traceblockbyhash.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_traceblockbyhash.md
new file mode 100644
index 0000000..0c7a95f
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_traceblockbyhash.md
@@ -0,0 +1,106 @@
+# debug\_traceBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const result = await tatum.rpc.debugTraceBlockByHash(
+'0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d',
+{tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlockByHash` is an RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during each transaction, including the input, output, and depth of the calls.
+
+### Parameters
+
+* `block_hash` (required): The hash of the block to be traced.
+ * Example: `"0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an array of objects, each representing the trace result of a transaction within the block. Each object contains the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlockByHash",
+ "params": [
+ "0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c",
+ {
+ "tracer": "callTracer",
+ "timeout": "10s"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_traceblockbynumber.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_traceblockbynumber.md
new file mode 100644
index 0000000..85e8d67
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_traceblockbynumber.md
@@ -0,0 +1,110 @@
+# debug\_traceBlockByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const result = await tatum.rpc.debugTraceBlockByNumber('0x1E3C299' , {
+ tracer: 'callTracer',
+ tracerConfig: {
+ onlyTopCall: true,
+ timeout: '10',
+ }
+})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlockByNumber` is an RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during each transaction, including the input, output, and depth of the calls.
+
+### Parameters
+
+* `blockNumber` - `Quantity` or `String`
+ * The block number of the block to trace.
+ * Example: `"0x1"` or `"latest"`
+* `options` as `tracerConfig`(optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (required): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "10s"). Default is "5s".
+ * Example: `tracerConfig: { onlyTopCall: true, timeout: '10', }`
+
+### Return Object
+
+The return object is an array of objects, each representing the trace result of a transaction within the block. Each object contains the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlockByNumber",
+ "params": [
+ "latest",
+ {
+ "tracer": "callTracer",
+ "timeout": "10s"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_tracecall.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_tracecall.md
new file mode 100644
index 0000000..cf74015
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_tracecall.md
@@ -0,0 +1,121 @@
+# debug\_traceCall
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const tatum = await TatumSDK.init({network: Network.EON})
+
+const result = await tatum.rpc.debugTraceCall({
+ "from": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ "to": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e87",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0xAD7C5E",
+ {tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceCall` is an RPC method that allows you to execute a given call (message), tracing the steps of its execution. This can be helpful for developers and auditors who want to inspect and analyze the internal operations and state changes of a contract call without modifying the blockchain state. This method can assist in debugging and identifying potential issues with contract execution, as well as understanding how gas is consumed during the execution of a call.
+
+### Parameters
+
+The `debug_traceCall` method accepts the following parameters:
+
+* `transaction`: An object that contains the following fields:
+ * `from`: The address from which the call is initiated. Example: `"0xa7d9ddbe1f17865597fbd27ec712455208b6b76d"`
+ * `to`: The address of the contract to be called. Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+ * `gas`: (Optional) The gas limit for the call. Example: `"0x76c0"`
+ * `gasPrice`: (Optional) The gas price for the call. Example: `"0x9184e72a000"`
+ * `value`: (Optional) The value to be transferred during the call. Example: `"0x9184e72a"`
+ * `data`: (Optional) The input data for the call, encoded as a hexadecimal string. Example: `"0x606060..."`
+* `blockNumber`: The block number for which the call should be traced. Example: `"0x1b4"`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `output`: The output data from the call.
+* `gasUsed`: The total gas used by the call.
+* `calls`: An array of objects, each representing a nested call made during the call. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "debug_traceCall",
+ "params": [
+ {
+ "from": "0xa7d9ddbe1f17865597fbd27ec712455208b6b76d",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0x1b4"
+ ]
+}
+
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_tracetransaction.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_tracetransaction.md
new file mode 100644
index 0000000..9561ac1
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/archival-information/debug_tracetransaction.md
@@ -0,0 +1,102 @@
+# debug\_traceTransaction
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const result = await tatum.rpc.debugTraceTransaction('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9', {tracer:'callTracer'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceTransaction` is an RPC method that allows developers to inspect and trace the execution of a specific transaction, providing valuable insight into the internal workings of the transaction, including the calls made between contracts, the state of the contracts, and any errors encountered during the transaction.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during the transaction, including the input, output, and the depth of the calls. This is particularly useful in debugging complex transactions, analyzing gas consumption, and understanding the flow of execution within smart contracts.
+
+### Parameters
+
+* `transaction_hash` (required): The hash of the transaction to trace.
+ * Example: `"0x123f681646d4a755815f9cb19e1acc8565a0c2ac"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "debug_traceTransaction",
+ "params": ["0x920d562e886a0c7c1f07ecee2ee5557f72d3056b205f8811c57e2615a3b6adb0", {"tracer":"callTracer"}],
+ "id": 2
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/README.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/README.md
new file mode 100644
index 0000000..563f334
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/README.md
@@ -0,0 +1,2 @@
+# Mempool
+
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool_content.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool_content.md
new file mode 100644
index 0000000..3b7a538
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool_content.md
@@ -0,0 +1,129 @@
+# txpool\_content
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const content = await tatum.rpc.txPoolContent()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_content` method provides information about the transactions currently pending in the transaction pool of the Flare node. It can be helpful for developers and node operators to monitor and manage the transaction pool, especially in scenarios where it's necessary to analyze transaction congestion or prioritize specific transactions.
+
+Use cases for the `txpool_content` method include:
+
+* Analyzing network congestion by inspecting the transaction pool
+* Prioritizing transactions by gas price
+* Monitoring transactions from specific addresses
+* Debugging and troubleshooting pending transactions
+
+### Parameters
+
+This method does not require any parameters.
+
+### Return Object
+
+The `txpool_content` method returns an object with two fields: `pending` and `queued`. Each field contains a nested object with addresses as keys and their respective transactions as values.
+
+* **`pending`**: An object containing transactions that are currently pending for inclusion in the next block(s).
+* **`queued`**: An object containing transactions that are currently queued (i.e., transactions that do not meet certain criteria for inclusion in the next block, like low gas price or nonce gaps).
+
+Each transaction object includes the following information:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Request Example
+
+```json
+jsonCopy code{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "txpool_content",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x01d3b93aaade8a4066daabc8fd8482173a6ad120",
+ "gas": "0x1c9c380",
+ "gasPrice": "0x16cf917",
+ "maxFeePerGas": "0x16cf917",
+ "maxPriorityFeePerGas": "0x16cf917",
+ "hash": "0x1da9c2a8f0787bac4747c5ed1035e81f6a6745aeea43943e63635fc367b817f7",
+ "input": "0x00000000",
+ "nonce": "0xc5",
+ "to": "0x4f023eb8c6bc3116e35b67e03bf2c17f2e4f7e7e",
+ "transactionIndex": null,
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0x14f7578b57fd9f87acf5bbceb0a47f2d2d3f39b49169357457618c9634c45e8a",
+ "s": "0x775fa9976c571751a79f069f8c96f6489f286246e157a31fa99b33062631b46d"
+ }
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x03321406635a04d37cf9211f2ea3afc83a87e777",
+ "gas": "0x5208",
+ "gasPrice": "0xc570bd200",
+ "hash": "0x05f5fb8e46793fafdc924917c0afdd0afb4a53cb562542d5399234bc1eff759b",
+ "input": "0x",
+ "nonce": "0x4dc359",
+ "to": "0x77b1c86ab0aa9066803ed567e1f00973976638f6",
+ "transactionIndex": null,
+ "value": "0xb1a2b96602aa20",
+ "type": "0x0",
+ "chainId": "0xaa36a7",
+ "v": "0x1546d72",
+ "r": "0x62bd220b95ec13827c0d9b643b9beaf6f4c66d4a8ef08bb10f93d5e5c7ae0068",
+ "s": "0x467f76847cfdf43a002defe054030c1a88a9e6f56539c051c3cba46b2dd2cc89"
+ }
+ }
+ }
+ }
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool_inspect.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool_inspect.md
new file mode 100644
index 0000000..eb6b0f7
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool_inspect.md
@@ -0,0 +1,76 @@
+# txpool\_inspect
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const inspect = await tatum.rpc.txPoolInspect()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_inspect` method is a JSON-RPC method used to inspect the current transaction pool of a running node. The method allows you to view all pending transactions and their details, including transaction hashes, gas prices, and transaction data. This method is useful for developers who want to monitor the status of pending transactions or debug transaction-related issues.
+
+### Parameters
+
+The `txpool_inspect` method takes one optional parameter:
+
+* **`include`**: A string specifying the type of transactions to include in the response. Possible values are **`pending`** (default) and **`queued`**.
+
+### Return Object
+
+The `txpool_inspect` method returns an object with the following fields:
+
+* **`pending`**: An array of transaction objects, with textual data
+* **`queued`**: An array of transaction objects, with textual data
+
+## Example Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "txpool_inspect",
+ "params": [
+ "pending"
+ ],
+ "id": 1
+}
+```
+
+## Example Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": "0x4f023eB8C6BC3116E35B67E03bf2C17f2e4f7e7e: 0 wei + 30000000 gas ร 23918871 wei"
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 49999988041886240 wei + 21000 gas ร 53000000000 wei",
+ "8308536": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 100000000000000000 wei + 21000 gas ร 53000000000 wei",
+ "231211221": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 1000000000000000 wei + 21000 gas ร 11958113760 wei"
+ }
+ }
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool_status.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool_status.md
new file mode 100644
index 0000000..638c21f
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/mempool/txpool_status.md
@@ -0,0 +1,64 @@
+# txpool\_status
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const status = await tatum.rpc.txPoolStatus()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_status` method returns statistics about the current state of the transaction pool. The transaction pool is a queue of pending transactions waiting to be included in the next block by miners.
+
+This method can be useful for monitoring the health of the network and analyzing the behavior of the miners. It can also be used to estimate the time it will take for a transaction to be processed, as well as to determine the gas price necessary to ensure prompt inclusion of a transaction in the next block.
+
+### Parameters
+
+This method does not take any parameters.
+
+### Return Object
+
+The `txpool_status` method returns an object with the following fields:
+
+* **`pending`**: Number of pending transactions in the pool
+* **`queued`**: Number of queued transactions in the pool
+
+### Example Request
+
+```json
+{
+ "jsonrpc":"2.0",
+ "method":"txpool_status",
+ "params":[],
+ "id":1
+}
+```
+
+### Example Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": 4,
+ "queued": 10
+ }
+}
+```
+
+In this example response, there are currently 4 pending transactions and 10 queued transactions waiting to be processed by miners.
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/README.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/README.md
new file mode 100644
index 0000000..bd96ae8
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/README.md
@@ -0,0 +1,2 @@
+# Network/Client information
+
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/eth_chainid.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/eth_chainid.md
new file mode 100644
index 0000000..5b7a0d0
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/eth_chainid.md
@@ -0,0 +1,61 @@
+# eth\_chainId
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const id = await tatum.rpc.chainId()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_chainId` method is an JSON-RPC method that allows developers to retrieve the currently configured chain ID of the network they are connected to. The chain ID is a unique identifier for different networks, such as mainnet or various testnets.
+
+This method is particularly useful when building applications that interact with multiple networks or need to verify the network to prevent replay attacks. By checking the chain ID, an application can ensure it is interacting with the intended network.
+
+### Parameters
+
+The `eth_chainId` method does not have any input parameters.
+
+### Return Object
+
+The return object contains a single field:
+
+* **`chainId`**: The hexadecimal string representation of the chain ID.
+
+### Example Request and Response
+
+JSON-RPC request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_chainId",
+ "params": []
+}
+```
+
+JSON-RPC response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0xe"
+}
+```
+
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/web3_clientversion.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/web3_clientversion.md
new file mode 100644
index 0000000..1fc3784
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-client-information/web3_clientversion.md
@@ -0,0 +1,63 @@
+# web3\_clientVersion
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const version = await tatum.rpc.clientVersion()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`web3_clientVersion` is a method of the JSON-RPC API that allows the client to retrieve the current version of the client software being used by the node.
+
+This method is read-only and does not require authentication. The `web3_clientVersion` method can be used by developers to confirm the version of the client software they are using and ensure that it is compatible with their application.
+
+### Parameters
+
+This method has no parameters. It only retrieves the current version of the client software.
+
+### Return Object
+
+The `web3_clientVersion` method returns a string representing the version of the client software being used. The string includes the client name, version number, and build information.
+
+* `String` - Version string of the client software being used.
+
+### Example Request
+
+#### JSON Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "web3_clientVersion",
+ "params": [],
+ "id": 1
+}
+```
+
+### Example Response
+
+#### JSON Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 67,
+ "result": "v0.9.0"
+}
+```
+
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/README.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/README.md
new file mode 100644
index 0000000..cbe8e09
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/README.md
@@ -0,0 +1,2 @@
+# Network state
+
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_blocknumber.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_blocknumber.md
new file mode 100644
index 0000000..1434202
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_blocknumber.md
@@ -0,0 +1,69 @@
+# eth\_blockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const latestBlock = await tatum.rpc.blockNumber()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_blockNumber` method returns the number of the most recent block on the blockchain. This method is commonly used to track the current state of the network, monitor for new blocks, or fetch historical data.
+
+Use cases for `eth_blockNumber` include:
+
+* Synchronising a local copy of the blockchain with the network
+* Checking the status of a transaction by comparing its block number to the current block number
+* Determining the current network state for smart contract interactions\
+
+
+### Parameters
+
+The `eth_blockNumber` method does not require any parameters.
+
+### Return Object
+
+The `eth_blockNumber` method returns a single field:
+
+* **`blockNumber`**: The number of the most recent block on the blockchain. The value is returned as a hexadecimal string.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_blockNumber",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4b7" // 1207
+}
+```
+
+In this example, the most recent block number is 1207 (`0x4b7` in hexadecimal notation).
+
+Please note that while this document provides a comprehensive description of the `eth_blockNumber` RPC method, other methods may be needed to obtain full transaction details or perform more complex tasks. Refer to the [Ethereum JSON-RPC documentation](https://eth.wiki/json-rpc/API) for more information.
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_call.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_call.md
new file mode 100644
index 0000000..f6416da
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_call.md
@@ -0,0 +1,79 @@
+# eth\_call
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const result = await tatum.rpc.call({
+ "to": "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d", // Replace with the ERC-20 token contract address, in this case wrapped SOL on Ethereum
+ "data": "0x70a082310000000000000000000000008894E0a0c962CB723c1976a4421c95949bE2D4E3" // The function signature for balanceOf(address), followed by the Ethereum address (F22981C5bF0A717c98781Af04fdc8213fA789F1C) to query, in this case holder of wrapped SOL tokens
+}, "latest")
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+Executes a new message call immediately without creating a transaction on the block chain. Often used for executing read-only smart contract functions, for example the `balanceOf` for an ERC-20 contract.
+
+Top 5 most commonly used use cases for `eth_call`:
+
+1. **Retrieve Token Balance:** Check an ERC-20 token balance for an address.
+2. **Query Contract State:** Get contract data, like a game score or auction status.
+3. **Validate Inputs:** Pre-validate function inputs before sending a transaction.
+4. **Price Oracles:** Fetch real-time price data for decentralized applications.
+5. **Gas Estimation:** Estimate gas costs for future transactions.
+
+### **Parameters**
+
+1. `Object` - The transaction call object
+
+* `from`: `DATA`, 20 Bytes - (optional) The address the transaction is sent from.
+* `to`: `DATA`, 20 Bytes - The address the transaction is directed to.
+* `gas`: `QUANTITY` - (optional) Integer of the gas provided for the transaction execution. eth\_call consumes zero gas, but this parameter may be needed by some executions.
+* `gasPrice`: `QUANTITY` - (optional) Integer of the gasPrice used for each paid gas
+* `value`: `QUANTITY` - (optional) Integer of the value sent with this transaction
+* `data`: `DATA` - (optional) Hash of the method signature and encoded parameters. For details see [Ethereum Contract ABI in the Solidity documentation(opens in a new tab)](https://docs.soliditylang.org/en/latest/abi-spec.html)
+
+2. `QUANTITY|TAG` - integer block number, or the string `"latest"`, `"earliest"` or `"pending"`, see the [default block parameter](https://ethereum.org/en/developers/docs/apis/json-rpc/#default-block)
+
+### Return Object
+
+`DATA` - the return value of executed contract.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc":"2.0",
+ "method":"eth_call",
+ "params":[{
+ "to": "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d", // Replace with the ERC-20 token contract address in this case USDC on Binance Smart Chain
+ "data": "0x70a082310000000000000000000000008894E0a0c962CB723c1976a4421c95949bE2D4E3" // The function signature for balanceOf(address), followed by the Ethereum address to query in this case holder of USDC tokens
+ },"latest"],
+ "id":1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x0000000000000000000000000000000000000000002f798bddfae24274770b92"
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getbalance.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getbalance.md
new file mode 100644
index 0000000..f231355
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getbalance.md
@@ -0,0 +1,108 @@
+# eth\_getBalance
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const balance = await tatum.rpc.getBalance('0x35a84E6896Aa5Ba047221aC405afaF1977A75109')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+// dotnet add ${your_project} package Tatum
+
+var tatumSdk = await TatumSdk.InitAsync();
+
+var rpcCall = new JsonRpcCall
+{
+ Id = "1",
+ JsonRpc = "2.0",
+ Method = "eth_getBalance",
+ Params = new object[]
+ {
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ }
+};
+
+var result = await tatumSdk.Rpc.Flare.Call(rpcCall);
+```
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBalance` method is an JSON-RPC method that allows you to retrieve the balance of a specified address. This method can be used to query the balance of any address, whether it is a contract or an externally owned account (EOA). A common use case for this method is to display the current balance of a user's account in a wallet application or a decentralized application (DApp).
+
+### Parameters
+
+The method requires two parameters:
+
+1. **`address`** (required): The address of the account or contract whose balance you want to query.
+ * Example: `"0x35a84E6896Aa5Ba047221aC405afaF1977A75109"`
+2. **`blockParameter`** (optional): The block number or block identifier to specify the point in time for which you want to query the balance.
+ * Example: `"latest"` or `"0x1"`
+
+#### Transaction Details
+
+For the purpose of this documentation, we'll also describe the `transactions` field of a full transaction object. The `eth_getBalance` method does not return transaction details, but we provide this information for completeness.
+
+A full transaction object includes the following fields:
+
+* **`hash`**: The transaction hash.
+* **`nonce`**: The number of transactions made by the sender prior to this one.
+* **`blockHash`**: The hash of the block in which the transaction was included.
+* **`blockNumber`**: The block number in which the transaction was included.
+* **`transactionIndex`**: The index of the transaction in the block.
+* **`from`**: The sender's address.
+* **`to`**: The recipient's address (or `null` for contract creation transactions).
+* **`value`**: The value transferred, in wei.
+* **`gasPrice`**: The gas price provided by the sender, in wei.
+* **`gas`**: The maximum gas allowed for the transaction.
+* **`input`**: The data sent with the transaction (typically for contract interaction).
+* **`v`**, **`r`**, **`s`**: The raw signature values of the transaction.
+
+### Return Object
+
+The method returns a single field:
+
+* `result`: The Flare balance of the specified address in wei, as a hexadecimal string.
+ * Example: `"0x1a2e1a"`, which corresponds to `1,726,666` wei.
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBalance",
+ "params": [
+ "0x35a84E6896Aa5Ba047221aC405afaF1977A75109",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1a2e1a"
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblockbyhash.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblockbyhash.md
new file mode 100644
index 0000000..bcd94fd
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblockbyhash.md
@@ -0,0 +1,120 @@
+# eth\_getBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const block = await tatum.rpc.getBlockByHash('0xf6ab52aebd492d20f7d5aef604d3d35111ec3d0ea4387431222429828652c9a1', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByHash` is an JSON-RPC method that allows developers to query a specific block in the blockchain by its block hash. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+### Parameters
+
+The `eth_getBlockByHash` method accepts two parameters:
+
+1. **`blockHash`**: The hash of the block you want to retrieve information about.
+ * Type: `String`
+ * Example: `"0xf6ab52aebd492d20f7d5aef604d3d35111ec3d0ea4387431222429828652c9a1"`
+2. **`fullTransactionDetails`**: A boolean value indicating whether to return full transaction details or just transaction hashes.
+ * Type: `Boolean`
+ * Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByHash",
+ "params": ["0xf6ab52aebd492d20f7d5aef604d3d35111ec3d0ea4387431222429828652c9a1", true],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "baseFeePerGas": "0x0",
+ "difficulty": "0x2",
+ "extraData": "0xd88301020b846765746888676f312e32302e34856c696e7578000000b19df4a2f8b5830d77ffb86082b4f5f252d14a0114894d1a27ffd744abf6ad2b17ca03aee899d30472cd252fa552a55980b1ad815d100d9a0477068407cdac3e6bdf640a2f4ee08441719d7af44a6851f52b751e97a63f73bbda4b5193e065750c33ff685751e60546be875cf84c8401e3babba01c37c7cbb5104d70b946cb41fa58a4d9233ab8fbb5eb3157e4f47e660a418d098401e3babca0dada7f63e1e688bb4c038c65b59ae516095b530eb0aafa6670b25d79826e77fe80faf5f05a0b8058404f73d37dc8817e4756ce0fc98867164735f94604f43bdb3138fd9441d75eff0276f07ca4ae85aeb112e3cfac9b2a432d0e73e08622ff3d2200",
+ "gasLimit": "0x84fe2c6",
+ "gasUsed": "0xa41073",
+ "hash": "0xf6ab52aebd492d20f7d5aef604d3d35111ec3d0ea4387431222429828652c9a1",
+ "logsBloom": "0x34a61a1c00021592286002548f5e940711b04513241c06a91dea45c892210331814498885820b1614e122a82c472000198c3ce0c23027368b67a74209aa03a2bc4566012215e488c25445149a23d022d607290c5a96438ea00540085c62d460d4f0e00e02b22082420c5193a9518189d08523e4bd3686c1662125a11585805b6c00d4864221b10dc078946a41dc50f18402d9685782202a82d2de9c888ead0b202e8121e7b64aa11684834cd0f944620c5a90d2401868404116059253312526c98231546d1090856b060080f09bf52eca0d50dc3f8bbf074213140cb1621e6fc1971e9375b0083e0c38516d495a6ad04ad51840c023e8548732499d4a2ed25d2",
+ "miner": "0x9f8ccdafcc39f3c7d6ebf637c9151673cbc36b88",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1e3babd",
+ "parentHash": "0xdada7f63e1e688bb4c038c65b59ae516095b530eb0aafa6670b25d79826e77fe",
+ "receiptsRoot": "0xcf29bb7fc17c26f39b86c02b4b08f5b11763e3cc19497b58ef18049978b0c7cc",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x65cb",
+ "stateRoot": "0x89063043aaf47c7ff87de3e197d3e556c7752fb2e338ec2ab4626d0b60f0f2d8",
+ "timestamp": "0x65017610",
+ "totalDifficulty": "0x3c12b38",
+ "transactions": [],
+ "transactionsRoot": "0x28caed6a0174dc936da148dcf519eb66ab912c4a94eacc123a05ca66d03c224b",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblockbynumber.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblockbynumber.md
new file mode 100644
index 0000000..d8762f0
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblockbynumber.md
@@ -0,0 +1,134 @@
+# eth\_getBlockByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init<BinanceSmartChain>({network: Network.BINANCE_SMART_CHAIN})
+
+const block = await tatum.rpc.getBlockByNumber('latest', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByNumber` is an JSON-RPC method that allows developers to query a specific block in the blockchain by its block number. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+### Parameters
+
+There are two required parameters for this method:
+
+1. **`blockNumber`** - The block number of the block to be retrieved. This can be a hexadecimal string or one of the predefined aliases: `"earliest"`, `"latest"`, or `"pending"`.
+
+ Example: `"0x1b4"`
+2. **`returnFullTransactionObjects`** - A boolean value that determines whether the returned block contains complete transaction objects (`true`) or only transaction hashes (`false`).
+
+ Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByNumber",
+ "params": ["latest", true]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
new file mode 100644
index 0000000..b84e852
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
@@ -0,0 +1,68 @@
+# eth\_getBlockTransactionCountByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const response = await tatum.rpc.getBlockTransactionCountByHash('0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockTransactionCountByHash` is a RPC method used to fetch the number of transactions in a block by the block's hash. It is useful when you want to know the total number of transactions included in a specific block and don't want to retrieve the entire block data. This method can be used in various scenarios, such as monitoring the network activity or estimating transaction confirmation times.
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`blockHash`**: The hash of the target block for which the transaction count will be retrieved. It should be a valid 32-byte hex string.
+
+Example of the parameter:
+
+* `blockHash`: `"0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91"`
+
+### Return
+
+The method returns a single value:
+
+* `transactionCount`: The total number of transactions included in the specified block. It is returned as a hexadecimal value.
+
+### Examples
+
+#### JSON-RPC request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockTransactionCountByHash",
+ "params": [
+ "0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91"
+ ]
+}
+```
+
+#### JSON-RPC response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x147"
+}
+```
+
+In this example, the block with the hash `"0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"` has a total of 10 transactions (indicated by the hexadecimal value `"0xa"`).
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
new file mode 100644
index 0000000..8685fe9
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
@@ -0,0 +1,63 @@
+# eth\_getBlockTransactionCountByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const response = await tatum.rpc.getBlockTransactionCountByNumber('0x1E3C1A1')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBlockTransactionCountByNumber` JSON-RPC method allows you to retrieve the number of transactions in a specified block. This method is particularly useful when you need to analyze the transaction activity of a specific block. You can use it to gain insights into network usage, analyze the impact of specific events on the network, or monitor transaction congestion in certain blocks.
+
+### Parameters
+
+1. **`blockNumber`**: The block number for which the transaction count should be retrieved. It should be a hex-encoded value representing the block number.
+ * Example: `"0x1E3C1A1"` (block number 31703457)
+
+### Return Object
+
+The return object is a hex-encoded value representing the number of transactions in the specified block.
+
+* Example: `"0x147"` (327 transactions)
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBlockTransactionCountByNumber",
+ "params": ["0x1E3C1A1"]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x147"
+}
+```
+
+
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getcode.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getcode.md
new file mode 100644
index 0000000..50e993f
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getcode.md
@@ -0,0 +1,76 @@
+# eth\_getCode
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const code = await tatum.rpc.getCode('0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getCode` method is part of the JSON-RPC API, which allows users to interact with the blockchain. This method is specifically used to retrieve the contract code (bytecode) of an account at a specific block number. It is helpful when developers need to examine the bytecode of a deployed contract or validate that the contract code on the blockchain matches the intended code.
+
+Use cases for this method could include:
+
+* Debugging a smart contract
+* Verifying the integrity of a deployed contract
+* Analyzing contract bytecode for security vulnerabilities
+
+### Parameters
+
+The `eth_getCode` method accepts two parameters:
+
+1. **`address`** (string): The address of the contract whose bytecode you want to retrieve. This should be a 20-byte address, formatted as a hex string with a `0x` prefix.
+ * Example: `"0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"`
+2. **`block`** (string): The block number at which you want to retrieve the contract code. This can be specified as a hex string or one of the following special keywords:
+ * `"earliest"`: The first block in the blockchain
+ * `"latest"`: The most recent block in the blockchain
+ * `"pending"`: The upcoming block that is being mined
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The `eth_getCode` method returns a string representing the contract bytecode. The returned value is a hex string with a `0x` prefix.
+
+* If the account has contract code, the returned string will contain the bytecode.
+* If the account is not a contract or does not exist, the returned string will be `0x`.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getCode",
+ "params": [
+ "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x606060...code_here...3839"
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getlogs.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getlogs.md
new file mode 100644
index 0000000..1de72fe
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getlogs.md
@@ -0,0 +1,111 @@
+# eth\_getLogs
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const logs = await tatum.rpc.getLogs({ address : '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getLogs` method is an JSON-RPC method that allows developers to query logs generated by the network, specifically event logs emitted by smart contracts. These logs are an essential part of the ecosystem as they provide a way for developers to monitor contract events and track contract state changes.
+
+This method is particularly useful when building decentralized applications (dApps) that rely on events emitted by smart contracts, as it enables developers to retrieve logs based on specific filter criteria. By using `eth_getLogs`, developers can efficiently track and react to events happening on the blockchain.
+
+### Parameters
+
+The `eth_getLogs` method takes a single input parameter: an object containing the filter criteria. The filter object can have the following fields:
+
+* **`fromBlock`**: (optional) The starting block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"fromBlock": "0x1"`
+* **`toBlock`**: (optional) The ending block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"toBlock": "0x2"`
+* **`address`**: (optional) The address or list of addresses of the contracts to filter logs from. Can be a single address or an array of addresses.
+ * Example: `"address": "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"`
+* **`topics`**: (optional) An array of up to four 32-byte topics. Topics are order-dependent, and each topic can be an array of topic hashes or `null`.
+ * Example: `"topics": ["0x123..."]`
+* **`blockhash`**: (optional) The block hash to filter logs from. If provided, `fromBlock` and `toBlock` are ignored.
+ * Example: `"blockhash": "0xc6ef9..."`
+
+In addition to the above fields, the `transactions` field in the filter object can be specified to include full transaction details instead of just transaction hashes. This is useful when you need more information about the transactions in which the events were emitted.
+
+### Return Object
+
+The `eth_getLogs` method returns an array of log objects. Each log object contains the following fields:
+
+* **`removed`**: A boolean indicating whether the log was removed due to a chain reorganization.
+ * Example: `"removed": false`
+* **`logIndex`**: The log index position in the block.
+ * Example: `"logIndex": "0x1"`
+* **`transactionIndex`**: The transaction index position in the block.
+ * Example: `"transactionIndex": "0x0"`
+* **`transactionHash`**: The hash of the transaction that emitted the log.
+ * Example: `"transactionHash": "0x88eef..."`
+* **`blockHash`**: The hash of the block containing the log.
+ * Example: `"blockHash": "0xc6ef9..."`
+* **`blockNumber`**: The block number containing the log.
+ * Example: `"blockNumber": "0x1"`
+* **`address`**: The address of the contract that emitted the log.
+ * Example: `"address": "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"`
+* **`data`**: The data associated with the log.
+ * Example: `"data":"0x0000000000000000000000000000000000000000000000000000000000000020"`
+* **`topics`**: An array of topics (order-dependent) associated with the log.
+ * Example: `"topics": ["0x123..."]`
+
+## JSON-RPC Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getLogs",
+ "params": [
+ {
+ "fromBlock": "0x1",
+ "toBlock": "0x2",
+ "address": "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "removed": false,
+ "logIndex": "0x1",
+ "transactionIndex": "0x0",
+ "transactionHash": "0x88eef...",
+ "blockHash": "0xc6ef9...",
+ "blockNumber": "0x1",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "data": "0x0000000000000000000000000000000000000000000000000000000000000020",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+This documentation provides a comprehensive overview of the `eth_getLogs` JSON-RPC method, its parameters, return objects, and JSON-RPC examples. By using this method, developers can effectively query logs generated by the network and use the retrieved data to track and react to events happening on the blockchain.
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getproof.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getproof.md
new file mode 100644
index 0000000..f6f888b
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getproof.md
@@ -0,0 +1,94 @@
+# eth\_getProof
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const result = await tatum.rpc.getProof("0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+ "latest")
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getProof` is a JSON-RPC method that retrieves the Merkle-Patricia proof for an account, storage key-value pairs, and account transaction count. It allows developers to verify the state of an account or storage value at a specific block without needing the entire state trie. This method is particularly useful for light clients or off-chain applications that require proof of an account's state or specific storage values.
+
+### Parameters
+
+1. **`address`** - `Data`, 20 Bytes
+ * The address of the account.
+ * Example: `"0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86"`
+2. **`keys`** - `Array` of `Data`
+ * An array of storage keys for which the proof should be generated.
+ * Example: `["0x0000000000000000000000000000000000000000000000000000000000000000"]`
+3. **`blockNumber`** - `Quantity` or `String`
+ * The block number for which the proof should be generated.
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+1. **`accountProof`** - `Array` of `Data`
+ * The serialized Merkle-Patricia proof for the account.
+2. **`balance`** - `Quantity`
+ * The balance of the account at the specified block.
+3. **`codeHash`** - `Data`, 32 Bytes
+ * The hash of the code for the account at the specified block.
+4. **`nonce`** - `Quantity`
+ * The transaction count of the account at the specified block.
+5. **`storageProof`** - `Array` of `Object`
+ * An array of storage proof objects, one for each requested key, containing the following fields:
+ * `key` - `Data`, 32 Bytes: The storage key.
+ * `value` - `Quantity`: The storage value.
+ * `proof` - `Array` of `Data`: The serialized Merkle-Patricia proof for the key-value pair.
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getProof",
+ "params": [
+ "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ [
+ "0x0000000000000000000000000000000000000000000000000000000000000000"
+ ],
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "address": "0xa41d19f4258a388c639b7ccd938fce3fb7d05e86",
+ "accountProof": [],
+ "balance": "0x0",
+ "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+ "nonce": "0x0",
+ "storageHash": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ "storageProof": [{}]
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getstorageat.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getstorageat.md
new file mode 100644
index 0000000..8200b1e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getstorageat.md
@@ -0,0 +1,69 @@
+# eth\_getStorageAt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const response = await tatum.rpc.getStorageAt('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', '0x0')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getStorageAt` is an JSON-RPC method that allows you to query the storage value of a contract at a given position. It can be used to inspect the internal state of a smart contract. This method is particularly useful for developers, auditors, and analysts who want to examine contract storage values for various purposes, such as debugging, verifying contract behavior, or analyzing data.
+
+### Parameters
+
+`eth_getStorageAt` accepts three parameters:
+
+1. **`address`**: The address of the contract you want to query.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`position`**: The storage position (slot) you want to query.
+ * Example: `"0x0"`
+3. **`blockParameter`**: The block number, block hash, or one of the string literals (`"earliest"`, `"latest"` or `"pending"`), representing the point in the blockchain to query the storage value.
+ * Example: `"latest"`
+
+### Return Object
+
+The return object is a single string value, representing the storage value at the given position in the contract.
+
+* `result`: The storage value in a 32-byte (64 character) hexadecimal format.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getStorageAt",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "0x0",
+ "latest"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x0000000000000000000000000000000000000000000000000000000000000123"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
new file mode 100644
index 0000000..1d032e7
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
@@ -0,0 +1,98 @@
+# eth\_getTransactionByBlockHashAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const tx = await tatum.rpc.getTransactionByBlockHashAndIndex('0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91', 0)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockHash` (required): The hash of the block containing the transaction.
+ * Example: `"0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91"`
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a number in decimal.
+ * Example: 0
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockHashAndIndex",
+ "params": [
+ "0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91",
+ 0
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91",
+ "blockNumber": "0x1e3c1a1",
+ "from": "0x071e5581ea04d93336fd6d2557c56f5c6ab2bea8",
+ "gas": "0x35b63",
+ "gasPrice": "0x5af993e87",
+ "hash": "0x7d05b7e686241f7aa0593e30c819fc59deb14154576b9d048820726079cf1c69",
+ "input": "0x0000000000000000000001edd108f9d850100000000003e7dc5f9076ab0000004e5cb88aaf8227d9b7e61a7555cee07c617941ee0033",
+ "nonce": "0x14089d",
+ "to": "0x0000000000016a723d0d576df7dc79ec149ac760",
+ "transactionIndex": "0x0",
+ "value": "0x0",
+ "type": "0x0",
+ "v": "0x93",
+ "r": "0xbe4a49be222942d61aad6f995b33fe59aefeaf2c8e8d9a3fea595e11ec03810b",
+ "s": "0x3b22209ddfcc3737de2990195dd9b6bb350f1fb6265e7d06789abaa619467d1e"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
new file mode 100644
index 0000000..84de165
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
@@ -0,0 +1,98 @@
+# eth\_getTransactionByBlockNumberAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const tx = await tatum.rpc.getTransactionByBlockNumberAndIndex('0xAD7C5E', 0)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockNumber` (required): The hash of the block containing the transaction.
+ * Example: `"0xAD7C5E"`
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a hexadecimal value.
+ * Example: `"0x0"`
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockNumberAndIndex",
+ "params": [
+ "0xAD7C5E",
+ "0x0"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0xee7d93c17d84df49b2923ce6922a6d1d3dd7c9ad9e5a845c53de15309c2722ef",
+ "blockNumber": "0xad7c5e",
+ "from": "0xcd22db09c69935c3c660438fec1758f855def472",
+ "gas": "0xdbba0",
+ "gasPrice": "0x9502f9000",
+ "hash": "0x182c841ef47c1505e1e38677b9f1cfea74ad5a380e31e6b05b68279e9d332e99",
+ "input": "0x095ea7b300000000000000000000000010ed43c718714eb63d5aa57b78b54704e256024effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+ "nonce": "0xd",
+ "to": "0x5e12bb6ddd9214923d6c837ddf1ffb9c90f18883",
+ "transactionIndex": "0x0",
+ "value": "0x0",
+ "type": "0x0",
+ "v": "0x94",
+ "r": "0xa4967df17dd1418b50808e44019335b6ff831e17962c1e143777c2808d7f2cd0",
+ "s": "0x43bdb946e52562c586ac6bf04e7d4c7e7252d2bfb455d3f5f486f64f34e40c33"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionbyhash.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionbyhash.md
new file mode 100644
index 0000000..d5059ef
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionbyhash.md
@@ -0,0 +1,91 @@
+# eth\_getTransactionByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const tx = await tatum.rpc.getTransactionByHash('0xc5e257842e8fb62e286350d4bdddcaf24cb30dae4b8ec25ad3e52f463e16e656')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByHash` is an JSON-RPC method that allows you to query transaction details based on its hash. This method is useful when you want to retrieve information about a specific transaction, such as its sender, receiver, value, and more. Common use cases include tracking transaction status, monitoring incoming transactions, or analyzing historical transaction data.
+
+### Parameters
+
+The `eth_getTransactionByHash` method takes one parameter:
+
+* **`transactionHash`**: The hash of the transaction you want to retrieve. This should be a 32-byte hash string with a `0x` prefix.
+ * Example: `"0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"`
+
+### Return Object
+
+The method returns a transaction object with the following fields:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getTransactionByHash",
+ "params": ["0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"],
+ "id": 1
+}
+```
+
+Response:
+
+```json
+{
+ jsonrpc: '2.0',
+ id: 1,
+ result: {
+ blockHash: '0x283da208c3429f3c3c38fc2c0a94bc767c9c2197962393cd4d79c6d6f2938b48',
+ blockNumber: '0x1e3bb30',
+ from: '0x35a84e6896aa5ba047221ac405afaf1977a75109',
+ gas: '0x5208',
+ gasPrice: '0xb2d05e00',
+ hash: '0xc5e257842e8fb62e286350d4bdddcaf24cb30dae4b8ec25ad3e52f463e16e656',
+ input: '0x',
+ nonce: '0x4',
+ to: '0x8aca17bcb5eed52e9854528d131d830149e9cdc0',
+ transactionIndex: '0x35',
+ value: '0x2386f26fc10000',
+ type: '0x0',
+ v: '0x94',
+ r: '0xdb1edfd341493c5309952a880db14f291820940f78cedfe0639a65babe564c5a',
+ s: '0x334ba27525743ff412e66b07bcb3683d0ed565edbad5a3e30ddd5d7f46233818'
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactioncount.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactioncount.md
new file mode 100644
index 0000000..2d0db3a
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactioncount.md
@@ -0,0 +1,74 @@
+# eth\_getTransactionCount
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const result = await tatum.rpc.getTransactionCount('0x35a84E6896Aa5Ba047221aC405afaF1977A75109', 'pending')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getTransactionCount` method is an JSON-RPC method that retrieves the number of transactions sent from a given address. It is a useful method for developers who need to keep track of an account's nonce value to avoid transaction collisions or incorrect order of execution. The nonce value is essential for ensuring transaction uniqueness and preventing replay attacks.
+
+Use cases for this method include:
+
+* Determining the nonce value for a new transaction to be sent from a specific address
+* Monitoring the number of transactions sent by an address to observe its activity
+* Troubleshooting transaction issues and verifying if a transaction was submitted successfully
+
+### Parameters
+
+The `eth_getTransactionCount` method accepts two parameters:
+
+1. **`address`** - The address whose transaction count will be retrieved.
+ * Example: `"0x35a84E6896Aa5Ba047221aC405afaF1977A75109"`
+2. **`blockParameter`** - A string indicating the block number or block state to consider when retrieving the transaction count.
+ * Possible values: `"earliest"`, `"latest"`, `"pending"`, or a specific block number in hexadecimal format
+ * Example: `"latest"`
+
+### Return Object
+
+The method returns a single value:
+
+* **`transactionCount`** - A hexadecimal representation of the number of transactions sent from the specified address.
+ * Example: `"0x1e"`
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionCount",
+ "params": [
+ "0x35a84E6896Aa5Ba047221aC405afaF1977A75109",
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1e"
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionreceipt.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionreceipt.md
new file mode 100644
index 0000000..b4c8298
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_gettransactionreceipt.md
@@ -0,0 +1,108 @@
+# eth\_getTransactionReceipt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const tx = await tatum.rpc.getTransactionReceipt('0xc5e257842e8fb62e286350d4bdddcaf24cb30dae4b8ec25ad3e52f463e16e656')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionReceipt` is an JSON-RPC method that retrieves the transaction receipt of a given transaction hash. This method is particularly useful when you need to obtain detailed information about a transaction's execution, such as its status (success or failure), gas usage, and logs (events). Common use cases include checking the status of a transaction after it has been mined or inspecting the events emitted by a smart contract during a specific transaction.
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`transactionHash`**: The hash of the transaction for which you want to obtain the receipt.
+ * Example: `"0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+* **`transactionHash`**: The hash of the transaction.
+* **`transactionIndex`**: The transaction's index position in the block.
+* **`blockHash`**: The hash of the block where this transaction was mined.
+* **`blockNumber`**: The block number where this transaction was mined.
+* **`from`**: The address of the sender.
+* **`to`**: The address of the receiver. `null` when it's a contract creation transaction.
+* **`cumulativeGasUsed`**: The total amount of gas used when this transaction was executed in the block.
+* **`gasUsed`**: The amount of gas used by this specific transaction alone.
+* **`contractAddress`**: The address of the contract created, if the transaction was a contract creation. Otherwise, `null`.
+* **`logs`**: An array of log objects, which were emitted during the transaction.
+* **`logsBloom`**: A 256-byte bloom filter, which is a compressed representation of the logs emitted during the transaction.
+* **`status`**: The status of the transaction's execution. `"0x1"` indicates success, while `"0x0"` indicates failure.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionReceipt",
+ "params": [
+ "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "contractAddress": null,
+ "cumulativeGasUsed": "0x7ad81",
+ "effectiveGasPrice": "0x306dc421e",
+ "from": "0x53e8577c4347c365e4e0da5b57a589cb6f2ab848",
+ "gasUsed": "0x3c518",
+ "logs": [
+ {
+ "address": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "topics": [
+ "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "0x00000000000000000000000074b4551c177592a908c6ab9ce671bfe8c1b5bd40",
+ "0x000000000000000000000000000000000000000000000000000056b990e70e00"
+ ],
+ "data": "0x",
+ "blockNumber": "0x316624",
+ "transactionHash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "transactionIndex": "0x4",
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "logIndex": "0x3",
+ "removed": false
+ }
+ ],
+ "logsBloom": "0x00000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000020000010000000000000800000000000000000000000010000040000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000100000000000000000000000000000000002000000200000000000100000000000800000000000000000000020000000000000000000000200000000000000000000000000000000000000000000",
+ "status": "0x1",
+ "to": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "transactionHash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "transactionIndex": "0x4",
+ "type": "0x0"
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getunclecountbyblockhash.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
new file mode 100644
index 0000000..67b70d2
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
@@ -0,0 +1,70 @@
+# eth\_getUncleCountByBlockHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const result = await tatum.rpc.getUncleCountByBlockHash('0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the network and to analyze the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralization of the network. The inclusion of uncles helps prevent centralization and ensures the mining process remains competitive.
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockHash`: The hash of the block for which you want to get the uncle count.
+ * Example value: `"0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91"`
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockHash` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockHash",
+ "params": [
+ "0xd109a2054e3301c446573859bcbdb0fb26107ea1c218d097042b34e3bd8f6d91"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x0"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
new file mode 100644
index 0000000..364eb21
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
@@ -0,0 +1,71 @@
+# eth\_getUncleCountByBlockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const result = await tatum.rpc.getUncleCountByBlockNumber('0xAD7C5E')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the network and to analyze the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralization of the network. The inclusion of uncles helps prevent centralization and ensures the mining process remains competitive.
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockNumber`: The number of the block for which you want to get the uncle count.
+ * Example value: `"0xAD7C5E"`
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockNumber` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockNumber",
+ "params": [
+ "0xAD7C5E"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x1"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/README.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/README.md
new file mode 100644
index 0000000..1b1ccbc
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/README.md
@@ -0,0 +1,2 @@
+# Transaction
+
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_estimategas.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_estimategas.md
new file mode 100644
index 0000000..bfd900c
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_estimategas.md
@@ -0,0 +1,92 @@
+# eth\_estimateGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const estimate = await tatum.rpc.estimateGas({
+ "from": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ "to": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e87",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060"
+ })
+
+ tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_estimateGas` is an JSON-RPC method that estimates the amount of gas required to execute a given transaction. This method can be used to determine the gas cost before sending a transaction, allowing developers to better predict the gas fees and avoid issues like out-of-gas errors.
+
+Use cases for `eth_estimateGas` include:
+
+* Estimating gas costs for contract deployments
+* Estimating gas costs for contract function calls
+* Estimating gas costs for standard transfers
+
+### Parameters
+
+The `eth_estimateGas` method takes a single parameter, an object representing the transaction details. The fields in the transaction object include:
+
+* **`from`** (optional, string): The address that the transaction is sent from.
+ * Example: `"from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`to`** (optional, string): The address the transaction is sent to.
+ * Example: `"to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`gas`** (optional, string): The maximum amount of gas provided for the transaction.
+ * Example: `"gas": "0x76c0"`
+* **`gasPrice`** (optional, string): The price of gas in wei.
+ * Example: `"gasPrice": "0x9184e72a000"`
+* **`value`** (optional, string): The amount of ZEN to send in the transaction, in wei.
+ * Example: `"value": "0xde0b6b3a7640000"`
+* **`data`** (optional, string): The data payload of the transaction, typically used for contract function calls or contract deployment.
+ * Example: `"data": "0x606060..."`
+* **`nonce`** (optional, string): The transaction count of the `from` address.
+ * Example: `"nonce": "0x1"`
+
+### Return Object
+
+The return value of the `eth_estimateGas` method is a single field:
+
+* `gasEstimate` (string): The estimated gas cost for the transaction, represented as a hexadecimal string.
+ * Example: `"0x5208"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_estimateGas",
+ "params": [
+ {
+ "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060..."
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x5208"
+}
+```
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_gasprice.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_gasprice.md
new file mode 100644
index 0000000..e44ddf1
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_gasprice.md
@@ -0,0 +1,60 @@
+# eth\_gasPrice
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const gasPrice = await tatum.rpc.gasPrice()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_gasPrice` method is an JSON-RPC method used to estimate the average gas price required for transactions in the network. This method provides a suggestion for the gas price to be used in a transaction to increase the likelihood of it being mined and included in a block in a reasonable amount of time. The `eth_gasPrice` method is particularly useful for developers and users who want to create and send transactions, as it helps them estimate the appropriate gas price to ensure timely processing.
+
+### Parameters
+
+The `eth_gasPrice` method does not require any parameters.
+
+### Return Value
+
+The `eth_gasPrice` method returns a single value as a hexadecimal string:
+
+* `gasPrice`: The estimated average gas price in wei. Example: `"0x4a817c800"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_gasPrice",
+ "params": []
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4a817c800"
+}
+```
+
+By using the `eth_gasPrice` method, developers and users can estimate the appropriate gas price for their transactions, improving the overall user experience and ensuring that their transactions are processed in a timely manner.
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_maxpriorityfeepergas.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
new file mode 100644
index 0000000..76f993d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
@@ -0,0 +1,62 @@
+# eth\_maxPriorityFeePerGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const gasPrice = await tatum.rpc.maxPriorityFeePerGas()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_maxPriorityFeePerGas` RPC method is used to retrieve the maximum priority fee per gas set by the user for a transaction. This method can be used to determine the maximum fee that can be paid for a transaction to be included in a block quickly.
+
+### Use case
+
+This method is particularly useful when the user wants to ensure that a transaction is processed quickly, even in a congested network where transaction fees may fluctuate rapidly. By setting a high maximum priority fee per gas, the user can ensure that the transaction is processed as quickly as possible.
+
+### Parameters
+
+`None.`
+
+## Return Object
+
+* `maxPriorityFeePerGas` - The maximum priority fee per gas the user is willing to pay, in wei.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_maxPriorityFeePerGas",
+ "params": [],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x3b9aca00"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_sendrawtransaction.md b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_sendrawtransaction.md
new file mode 100644
index 0000000..6d9093c
--- /dev/null
+++ b/docs/rpc/evm-blockchains/bsc-rpc-documentation/transaction/eth_sendrawtransaction.md
@@ -0,0 +1,62 @@
+# eth\_sendRawTransaction
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, BinanceSmartChain, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.BINANCE_SMART_CHAIN})
+
+const gasPrice = await tatum.rpc.sendRawTransaction('0x0000.......')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_sendRawTransaction` RPC method is used to send a signed and serialized transaction to the network. This method is particularly useful when you want to have full control over the signing process, e.g., when using hardware wallets, cold storage, or custom signing libraries. It can be utilized in various use cases, such as transferring, interacting with smart contracts, or deploying new contracts.
+
+### Parameters
+
+The method accepts a single parameter:
+
+* **`data`**: The signed and serialized transaction data as a hexadecimal string.
+
+### Return Value
+
+The method returns a single value:
+
+* `transactionHash`: The hash of the submitted transaction as a hexadecimal string, e.g., `"0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"`.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_sendRawTransaction",
+ "params": [
+ "0xf86d8201...94a7bc"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/README.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/README.md
new file mode 100644
index 0000000..bd9c86a
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/README.md
@@ -0,0 +1,11 @@
+# Ethereum RPC documentation
+
+Ethereum RPC (Remote Procedure Call) is a powerful tool for interacting with the Ethereum blockchain network. It provides developers with a standardised interface to communicate with the Ethereum network, enabling them to retrieve data, send transactions, deploy smart contracts, and more. With Ethereum RPC, developers can build decentralised applications, integrate blockchain functionality into existing systems, and explore the vast ecosystem of Ethereum.
+
+Getting Started with Ethereum RPC using Tatum SDK (Video Tutorial):
+
+{% embed url="https://youtu.be/ieMHdz5vqp4" %}
+Ethereum RPC
+{% endembed %}
+
+In this video tutorial, we will walk you through the process of getting started with Ethereum RPC using the Tatum SDK. Tatum SDK is a robust blockchain development toolkit that simplifies the interaction with various blockchain networks, including Ethereum. By following the tutorial, you will learn how to set up your development environment, establish a connection to the Ethereum network via RPC, and perform common operations such as retrieving gas fees. Whether you are a beginner or an experienced developer, this tutorial will provide you with the necessary steps to kickstart your web3 app development journey on ethereum.
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/README.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/README.md
new file mode 100644
index 0000000..1fb947d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/README.md
@@ -0,0 +1,2 @@
+# Archival information
+
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_storagerangeat.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_storagerangeat.md
new file mode 100644
index 0000000..13e653b
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_storagerangeat.md
@@ -0,0 +1,84 @@
+# debug\_storageRangeAt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.debugStorageRangeAt(
+'0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d',
+1, '0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', '0x0', '0x64'
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_storageRangeAt` is an RPC method that allows you to retrieve the contract storage range for a given block and address. This can be useful for developers and auditors who want to inspect the storage state of a specific contract at a particular point in time. This method can also help in debugging and identifying potential issues with contract storage, as well as understanding how storage evolves as transactions are executed.
+
+### Parameters
+
+The `debug_storageRangeAt` method accepts the following parameters:
+
+* `blockHash`: The block hash for which the storage range should be retrieved. Example: `"0x3c4523b7e8c21e3d68f1c3af3d18e8a87c0d43e35b2c1b7f8f4e87e4d4db9c82"`
+* `txIndex`: The transaction index within the specified block. Example: `1`
+* `address`: The contract address for which the storage range should be retrieved. Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* `begin`: The beginning of the storage range. Example: `"0x0"`
+* `end`: The end of the storage range. Example: `"0x64"` (inclusive)
+
+### Return Object
+
+The `debug_storageRangeAt` method returns an object with the following fields:
+
+* `storage`: An object that contains key-value pairs representing the contract storage, where the key is the storage slot and the value is the stored data. Example: `"0x00..01": "0x00..01"`
+* `nextKey`: A key indicating the next storage slot if the requested range is too large, otherwise `null`. Example: `"0x00..02"` or `null`
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "debug_storageRangeAt",
+ "params": [
+ "0x3c4523b7e8c21e3d68f1c3af3d18e8a87c0d43e35b2c1b7f8f4e87e4d4db9c82",
+ "0x1",
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "0x0",
+ "0x64"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000002"
+ },
+ "nextKey": "0x0000000000000000000000000000000000000000000000000000000000000065"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_traceblockbyhash.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_traceblockbyhash.md
new file mode 100644
index 0000000..8e90cb3
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_traceblockbyhash.md
@@ -0,0 +1,106 @@
+# debug\_traceBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.debugTraceBlockByHash(
+'0x3c4523b7e8c21e3d68f1c3af3d18e8a87c0d43e35b2c1b7f8f4e87e4d4db9c82',
+{tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlockByHash` is an Ethereum RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during each transaction, including the input, output, and depth of the calls.
+
+### Parameters
+
+* `block_hash` (required): The hash of the block to be traced.
+ * Example: `"0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an array of objects, each representing the trace result of a transaction within the block. Each object contains the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlockByHash",
+ "params": [
+ "0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c",
+ {
+ "tracer": "callTracer",
+ "timeout": "10s"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_tracecall.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_tracecall.md
new file mode 100644
index 0000000..9d9e0c9
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_tracecall.md
@@ -0,0 +1,112 @@
+# debug\_traceCall
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.debugTraceCall({
+ "from": "0xa7d9ddbe1f17865597fbd27ec712455208b6b76d",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0x1b4",
+ {tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceCall` is an Ethereum RPC method that allows you to execute a given call (message), tracing the steps of its execution. This can be helpful for developers and auditors who want to inspect and analyze the internal operations and state changes of a contract call without modifying the blockchain state. This method can assist in debugging and identifying potential issues with contract execution, as well as understanding how gas is consumed during the execution of a call.
+
+### Parameters
+
+* `blockNumber` - `Quantity` or `String`
+ * The block number of the block to trace.
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `output`: The output data from the call.
+* `gasUsed`: The total gas used by the call.
+* `calls`: An array of objects, each representing a nested call made during the call. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "debug_traceCall",
+ "params": [
+ {
+ "from": "0xa7d9ddbe1f17865597fbd27ec712455208b6b76d",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0x1b4"
+ ]
+}
+
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_tracetransaction.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_tracetransaction.md
new file mode 100644
index 0000000..0752340
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/debug_tracetransaction.md
@@ -0,0 +1,102 @@
+# debug\_traceTransaction
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.debugTraceTransaction('0x920d562e886a0c7c1f07ecee2ee5557f72d3056b205f8811c57e2615a3b6adb0', {tracer:'callTracer'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceTransaction` is an Ethereum RPC method that allows developers to inspect and trace the execution of a specific transaction, providing valuable insight into the internal workings of the transaction, including the calls made between contracts, the state of the contracts, and any errors encountered during the transaction.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during the transaction, including the input, output, and the depth of the calls. This is particularly useful in debugging complex transactions, analyzing gas consumption, and understanding the flow of execution within smart contracts.
+
+### Parameters
+
+* `transaction_hash` (required): The hash of the transaction to trace.
+ * Example: `"0x123f681646d4a755815f9cb19e1acc8565a0c2ac"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "debug_traceTransaction",
+ "params": ["0x920d562e886a0c7c1f07ecee2ee5557f72d3056b205f8811c57e2615a3b6adb0", {"tracer":"callTracer"}],
+ "id": 2
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/eth_getblockreceipts.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/eth_getblockreceipts.md
new file mode 100644
index 0000000..a17d232
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/archival-information/eth_getblockreceipts.md
@@ -0,0 +1,154 @@
+# eth\_getBlockReceipts
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.getBlockReceipts(10123321)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockReceipts` method retrieves and returns all transaction receipts for a specific block. Transaction receipts contain essential information related to the execution status and outcomes of individual transactions within the block, including details about the amount of gas used, contract events emitted, and whether the transactions were successful or not.
+
+By using the `eth_getBlockReceipts`, developers can seek a comprehensive overview of the transactions' results within a particular block.
+
+### Parameters
+
+The `eth_getBlockReceipts` method accepts the following parameters:
+
+* `blockNumber` - `Quantity` or `String`
+ * The block number of the block to trace.
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+`eth_getBlockReceipts` method provides a detailed set of information for each transaction receipt within a given block. The returned data includes:
+
+* `blockHash`: The hash of the block (null if pending).
+* `blockNumber`: The block number.
+* `contractAddress`: The contract address created if the transaction was for contract creation; otherwise, null.
+* `cumulativeGasUsed`: The total amount of gas used when this transaction was executed in the block.
+* `effectiveGasPrice`: The actual value per gas deducted from the sender account.
+* from: The address of the sender.
+* `gasUsed`: The amount of gas used by this specific transaction alone.
+* `logs`: An array of log objects that generated this transaction, containing:
+ * `address`: The address from which this log originated.
+ * topics: In Solidity, the first topic is the hash of the signature of the event, unless the event is declared with the anonymous specifier.
+ * `data`: It contains one or more 32 Bytes non-indexed arguments of the log.
+ * `blockNumber`: The block number where this log was in.
+ * `transactionHash`: The hash of the transaction this log was created from, or null if it's a pending log.
+ * `transactionIndex`: The integer of the transaction's index position that the log was created fromr null if it's a pending log.
+ * `blockHash`: The hash of the block where this log was inr null if it's a pending log.
+ * `logIndex`: The integer of the log index position in the blockr null if it's a pending log.
+ * `removed`: It is true when the log was removed due to a chain reorganization, and false if it's a valid log.
+* `logsBloom`: The bloom filter for light clients to quickly retrieve related logs.
+* `status`: It is either 1 (success) or 0 (failure) encoded as a hexadecimal.
+* `to`: The address of the receiver. It will be null when the transaction is for contract creation.
+* `transactionHash`: The hash of the transaction.
+* `transactionIndex`: The index of the transaction within the block.
+* `type`: The value type.
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc":"2.0",
+ "method":"eth_getBlockReceipts",
+ "params":["0x10f5d58"],
+ "id":1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": [
+ {
+ "blockHash": "0xf129ec079e3af6740128dde546e33ea85db2c46dbb7ea35f400a97bf837ec630",
+ "blockNumber": "0x10f5d58",
+ "contractAddress": null,
+ "cumulativeGasUsed": "0x3f14c",
+ "effectiveGasPrice": "0x174876e800",
+ "from": "0xcf33ea41c015749f3ced2366364ef611d8d1425d",
+ "gasUsed": "0x3f14c",
+ "logs": [
+ {
+ "address": "0xa62894d5196bc44e4c3978400ad07e7b30352372",
+ "topics": [
+ "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "0x000000000000000000000000cf33ea41c015749f3ced2366364ef611d8d1425d",
+ "0x000000000000000000000000a62894d5196bc44e4c3978400ad07e7b30352372"
+ ],
+ "data": "0x0000000000000000000000000000000000000000000000000002cbb24c4d2f98",
+ "blockNumber": "0x10f5d58",
+ "transactionHash": "0x81f1604ea2fa270307707d922d373e2e04069788334b648393aecb8c806ee6c0",
+ "transactionIndex": "0x0",
+ "blockHash": "0xf129ec079e3af6740128dde546e33ea85db2c46dbb7ea35f400a97bf837ec630",
+ "logIndex": "0x0",
+ "removed": false
+ },
+ {
+ "address": "0xa62894d5196bc44e4c3978400ad07e7b30352372",
+ "topics": [
+ "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "0x000000000000000000000000cf33ea41c015749f3ced2366364ef611d8d1425d",
+ "0x0000000000000000000000008e83de18b38ddc22166fb5454003a573a53be4ae"
+ ],
+ "data": "0x0000000000000000000000000000000000000000000000000114c5f381d9787d",
+ "blockNumber": "0x10f5d58",
+ "transactionHash": "0x81f1604ea2fa270307707d922d373e2e04069788334b648393aecb8c806ee6c0",
+ "transactionIndex": "0x0",
+ "blockHash": "0xf129ec079e3af6740128dde546e33ea85db2c46dbb7ea35f400a97bf837ec630",
+ "logIndex": "0x1",
+ "removed": false
+ }
+ ],
+ "logsBloom": "0x00200000000000000000000080000000008000000000000000000000000000000000000000000000000000000000000102002010880120000000000000200000000000080000000800004008000000200000000000400800000002000020000000000000000000000000000000000000008000000000040000000010000800002000000000000000001020080000812000000000000000080000004000000000020080000000000000000000000000400000000200000000000000000010080000000002000000000000000000000000000000000000101000000002000000004010200000000000000000000000000000001000000000000000000000000000",
+ "status": "0x1",
+ "to": "0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad",
+ "transactionHash": "0x81f1604ea2fa270307707d922d373e2e04069788334b648393aecb8c806ee6c0",
+ "transactionIndex": "0x0",
+ "type": "0x2"
+ },
+ {
+ "blockHash": "0xf129ec079e3af6740128dde546e33ea85db2c46dbb7ea35f400a97bf837ec630",
+ "blockNumber": "0x10f5d58",
+ "contractAddress": null,
+ "cumulativeGasUsed": "0xbd884a",
+ "effectiveGasPrice": "0x48ffe6b8e",
+ "from": "0xdafea492d9c6733ae3d56b7ed1adb60692c98bc5",
+ "gasUsed": "0x5208",
+ "logs": [],
+ "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "status": "0x1",
+ "to": "0xe688b84b23f322a994a53dbf8e15fa82cdb71127",
+ "transactionHash": "0x1104ac612589d19b6774ab1d8012c23036ebb5fae828b7a710acc6101b2b34bf",
+ "transactionIndex": "0x99",
+ "type": "0x2"
+ }
+ ]
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/README.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/README.md
new file mode 100644
index 0000000..563f334
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/README.md
@@ -0,0 +1,2 @@
+# Mempool
+
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool_content.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool_content.md
new file mode 100644
index 0000000..ac2f08d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool_content.md
@@ -0,0 +1,131 @@
+# txpool\_content
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const content = await tatum.rpc.txPoolContent()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_content` method provides information about the transactions currently pending in the transaction pool of the Ethereum node. It can be helpful for developers and node operators to monitor and manage the transaction pool, especially in scenarios where it's necessary to analyze transaction congestion or prioritize specific transactions.
+
+Use cases for the `txpool_content` method include:
+
+* Analyzing network congestion by inspecting the transaction pool
+* Prioritizing transactions by gas price
+* Monitoring transactions from specific addresses
+* Debugging and troubleshooting pending transactions
+
+{% embed url="https://codepen.io/tatum-devrel/pen/BaGMzLr" %}
+
+### Parameters
+
+This method does not require any parameters.
+
+### Return Object
+
+The `txpool_content` method returns an object with two fields: `pending` and `queued`. Each field contains a nested object with addresses as keys and their respective transactions as values.
+
+* **`pending`**: An object containing transactions that are currently pending for inclusion in the next block(s).
+* **`queued`**: An object containing transactions that are currently queued (i.e., transactions that do not meet certain criteria for inclusion in the next block, like low gas price or nonce gaps).
+
+Each transaction object includes the following information:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Request Example
+
+```json
+jsonCopy code{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "txpool_content",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x01d3b93aaade8a4066daabc8fd8482173a6ad120",
+ "gas": "0x1c9c380",
+ "gasPrice": "0x16cf917",
+ "maxFeePerGas": "0x16cf917",
+ "maxPriorityFeePerGas": "0x16cf917",
+ "hash": "0x1da9c2a8f0787bac4747c5ed1035e81f6a6745aeea43943e63635fc367b817f7",
+ "input": "0x00000000",
+ "nonce": "0xc5",
+ "to": "0x4f023eb8c6bc3116e35b67e03bf2c17f2e4f7e7e",
+ "transactionIndex": null,
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0x14f7578b57fd9f87acf5bbceb0a47f2d2d3f39b49169357457618c9634c45e8a",
+ "s": "0x775fa9976c571751a79f069f8c96f6489f286246e157a31fa99b33062631b46d"
+ }
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x03321406635a04d37cf9211f2ea3afc83a87e777",
+ "gas": "0x5208",
+ "gasPrice": "0xc570bd200",
+ "hash": "0x05f5fb8e46793fafdc924917c0afdd0afb4a53cb562542d5399234bc1eff759b",
+ "input": "0x",
+ "nonce": "0x4dc359",
+ "to": "0x77b1c86ab0aa9066803ed567e1f00973976638f6",
+ "transactionIndex": null,
+ "value": "0xb1a2b96602aa20",
+ "type": "0x0",
+ "chainId": "0xaa36a7",
+ "v": "0x1546d72",
+ "r": "0x62bd220b95ec13827c0d9b643b9beaf6f4c66d4a8ef08bb10f93d5e5c7ae0068",
+ "s": "0x467f76847cfdf43a002defe054030c1a88a9e6f56539c051c3cba46b2dd2cc89"
+ }
+ }
+ }
+ }
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool_inspect.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool_inspect.md
new file mode 100644
index 0000000..c40e878
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool_inspect.md
@@ -0,0 +1,78 @@
+# txpool\_inspect
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const inspect = await tatum.rpc.txPoolInspect()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_inspect` method is a JSON-RPC method used to inspect the current transaction pool of a running Ethereum node. The method allows you to view all pending transactions and their details, including transaction hashes, gas prices, and transaction data. This method is useful for developers who want to monitor the status of pending transactions or debug transaction-related issues.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/qBQgNqZ" %}
+
+### Parameters
+
+The `txpool_inspect` method takes one optional parameter:
+
+* **`include`**: A string specifying the type of transactions to include in the response. Possible values are **`pending`** (default) and **`queued`**.
+
+### Return Object
+
+The `txpool_inspect` method returns an object with the following fields:
+
+* **`pending`**: An array of transaction objects, with textual data
+* **`queued`**: An array of transaction objects, with textual data
+
+## Example Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "txpool_inspect",
+ "params": [
+ "pending"
+ ],
+ "id": 1
+}
+```
+
+## Example Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": "0x4f023eB8C6BC3116E35B67E03bf2C17f2e4f7e7e: 0 wei + 30000000 gas ร 23918871 wei"
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 49999988041886240 wei + 21000 gas ร 53000000000 wei",
+ "8308536": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 100000000000000000 wei + 21000 gas ร 53000000000 wei",
+ "231211221": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 1000000000000000 wei + 21000 gas ร 11958113760 wei"
+ }
+ }
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool_status.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool_status.md
new file mode 100644
index 0000000..a606dba
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/mempool/txpool_status.md
@@ -0,0 +1,64 @@
+# txpool\_status
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const status = await tatum.rpc.txPoolStatus()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_status` method returns statistics about the current state of the transaction pool. The transaction pool is a queue of pending transactions waiting to be included in the next block by miners.
+
+This method can be useful for monitoring the health of the Ethereum network and analyzing the behavior of the miners. It can also be used to estimate the time it will take for a transaction to be processed, as well as to determine the gas price necessary to ensure prompt inclusion of a transaction in the next block.
+
+### Parameters
+
+This method does not take any parameters.
+
+### Return Object
+
+The `txpool_status` method returns an object with the following fields:
+
+* **`pending`**: Number of pending transactions in the pool
+* **`queued`**: Number of queued transactions in the pool
+
+### Example Request
+
+```json
+{
+ "jsonrpc":"2.0",
+ "method":"txpool_status",
+ "params":[],
+ "id":1
+}
+```
+
+### Example Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": 4,
+ "queued": 10
+ }
+}
+```
+
+In this example response, there are currently 4 pending transactions and 10 queued transactions waiting to be processed by miners.
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/README.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/README.md
new file mode 100644
index 0000000..bd96ae8
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/README.md
@@ -0,0 +1,2 @@
+# Network/Client information
+
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/eth_chainid.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/eth_chainid.md
new file mode 100644
index 0000000..1addb8d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/eth_chainid.md
@@ -0,0 +1,64 @@
+# eth\_chainId
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const id = await tatum.rpc.chainId()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_chainId` method is an Ethereum JSON-RPC method that allows developers to retrieve the currently configured chain ID of the Ethereum network they are connected to. The chain ID is a unique identifier for different Ethereum networks, such as Ethereum Mainnet or various testnets.
+
+This method is particularly useful when building applications that interact with multiple Ethereum networks or need to verify the network to prevent replay attacks. By checking the chain ID, an application can ensure it is interacting with the intended network.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/eYQxzzw" %}
+
+### Parameters
+
+The `eth_chainId` method does not have any input parameters.
+
+### Return Object
+
+The return object contains a single field:
+
+* **`chainId`**: The hexadecimal string representation of the chain ID.
+
+### Example Request and Response
+
+JSON-RPC request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_chainId",
+ "params": []
+}
+```
+
+JSON-RPC response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1"
+}
+```
+
+In this example, the returned chain ID is `0x1`, which corresponds to the Ethereum Mainnet.
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/web3_clientversion.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/web3_clientversion.md
new file mode 100644
index 0000000..bb67d80
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-client-information/web3_clientversion.md
@@ -0,0 +1,66 @@
+# web3\_clientVersion
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const version = await tatum.rpc.clientVersion()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`web3_clientVersion` is a method of the Ethereum JSON-RPC API that allows the client to retrieve the current version of the Ethereum client software being used by the node.
+
+This method is read-only and does not require authentication. The `web3_clientVersion` method can be used by developers to confirm the version of the Ethereum client software they are using and ensure that it is compatible with their application.
+
+### Parameters
+
+This method has no parameters. It only retrieves the current version of the Ethereum client software.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/xxQMOEw" %}
+
+### Return Object
+
+The `web3_clientVersion` method returns a string representing the version of the Ethereum client software being used. The string includes the client name, version number, and build information.
+
+* `String` - Version string of the Ethereum client software being used.
+
+### Example Request
+
+#### JSON Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "web3_clientVersion",
+ "params": [],
+ "id": 67
+}
+```
+
+### Example Response
+
+#### JSON Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 67,
+ "result": "Geth/v1.10.3-stable-c2d2f1a3/linux-amd64/go1.16.4"
+}
+```
+
+In the above example, the Ethereum client software being used is Geth, version 1.10.3, with build information `stable-c2d2f1a3/linux-amd64/go1.16.4`. The `result` field contains the version string.
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/README.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/README.md
new file mode 100644
index 0000000..cbe8e09
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/README.md
@@ -0,0 +1,2 @@
+# Network state
+
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_blocknumber.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_blocknumber.md
new file mode 100644
index 0000000..d778901
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_blocknumber.md
@@ -0,0 +1,70 @@
+# eth\_blockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const latestBlock = await tatum.rpc.blockNumber()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_blockNumber` method returns the number of the most recent block on the Ethereum blockchain. This method is commonly used to track the current state of the network, monitor for new blocks, or fetch historical data.
+
+Use cases for `eth_blockNumber` include:
+
+* Synchronising a local copy of the blockchain with the network
+* Checking the status of a transaction by comparing its block number to the current block number
+* Determining the current network state for smart contract interactions
+
+{% embed url="https://codepen.io/tatum-devrel/pen/jOQdqzY?editors=1011" %}
+
+### Parameters
+
+The `eth_blockNumber` method does not require any parameters.
+
+### Return Object
+
+The `eth_blockNumber` method returns a single field:
+
+* **`blockNumber`**: The number of the most recent block on the Ethereum blockchain. The value is returned as a hexadecimal string.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_blockNumber",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4b7" // 1207
+}
+```
+
+In this example, the most recent block number is 1207 (`0x4b7` in hexadecimal notation).
+
+Please note that while this document provides a comprehensive description of the `eth_blockNumber` Ethereum RPC method, other methods may be needed to obtain full transaction details or perform more complex tasks. Refer to the [Ethereum JSON-RPC documentation](https://eth.wiki/json-rpc/API) for more information.
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_call.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_call.md
new file mode 100644
index 0000000..9c74900
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_call.md
@@ -0,0 +1,79 @@
+# eth\_call
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.call({
+ "to": "0xD31a59c85aE9D8edEFeC411D448f90841571b89c", // Replace with the ERC-20 token contract address, in this case wrapped SOL on Ethereum
+ "data": "0x70a08231000000000000000000000000F22981C5bF0A717c98781Af04fdc8213fA789F1C" // The function signature for balanceOf(address), followed by the Ethereum address (F22981C5bF0A717c98781Af04fdc8213fA789F1C) to query, in this case holder of wrapped SOL tokens
+}, "latest")
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+Executes a new message call immediately without creating a transaction on the block chain. Often used for executing read-only smart contract functions, for example the `balanceOf` for an ERC-20 contract.
+
+Top 5 most commonly used use cases for `eth_call`:
+
+1. **Retrieve Token Balance:** Check an ERC-20 token balance for an address.
+2. **Query Contract State:** Get contract data, like a game score or auction status.
+3. **Validate Inputs:** Pre-validate function inputs before sending a transaction.
+4. **Price Oracles:** Fetch real-time price data for decentralized applications.
+5. **Gas Estimation:** Estimate gas costs for future transactions.
+
+### **Parameters**
+
+1. `Object` - The transaction call object
+
+* `from`: `DATA`, 20 Bytes - (optional) The address the transaction is sent from.
+* `to`: `DATA`, 20 Bytes - The address the transaction is directed to.
+* `gas`: `QUANTITY` - (optional) Integer of the gas provided for the transaction execution. eth\_call consumes zero gas, but this parameter may be needed by some executions.
+* `gasPrice`: `QUANTITY` - (optional) Integer of the gasPrice used for each paid gas
+* `value`: `QUANTITY` - (optional) Integer of the value sent with this transaction
+* `data`: `DATA` - (optional) Hash of the method signature and encoded parameters. For details see [Ethereum Contract ABI in the Solidity documentation(opens in a new tab)](https://docs.soliditylang.org/en/latest/abi-spec.html)
+
+2. `QUANTITY|TAG` - integer block number, or the string `"latest"`, `"earliest"` or `"pending"`, see the [default block parameter](https://ethereum.org/en/developers/docs/apis/json-rpc/#default-block)
+
+### Return Object
+
+`DATA` - the return value of executed contract.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc":"2.0",
+ "method":"eth_call",
+ "params":[{
+ "to": "0xD31a59c85aE9D8edEFeC411D448f90841571b89c", // Replace with the ERC-20 token contract address in this case wrapped SOL on Ethereum
+ "data": "0x70a08231000000000000000000000000F22981C5bF0A717c98781Af04fdc8213fA789F1C" // The function signature for balanceOf(address), followed by the Ethereum address to query in this case holder of wrapped SOL tokens
+ },"latest"],
+ "id":1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x00000000000000000000000000000000000000000000000000001726f9fecc9d"
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getbalance.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getbalance.md
new file mode 100644
index 0000000..1b1cf91
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getbalance.md
@@ -0,0 +1,112 @@
+# eth\_getBalance
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const balance = await tatum.rpc.getBalance('0x742d35Cc6634C0532925a3b844Bc454e4438f44e')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+// dotnet add ${your_project} package Tatum
+
+var tatumSdk = await TatumSdk.InitAsync();
+
+var rpcCall = new JsonRpcCall
+{
+ Id = "1",
+ JsonRpc = "2.0",
+ Method = "eth_getBalance",
+ Params = new object[]
+ {
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ }
+};
+
+var result = await tatumSdk.Rpc.Ethereum.Call(rpcCall);
+```
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBalance` method is an Ethereum JSON-RPC method that allows you to retrieve the Ether balance of a specified address. This method can be used to query the balance of any Ethereum address, whether it is a contract or an externally owned account (EOA). A common use case for this method is to display the current balance of a user's account in a wallet application or a decentralised application (DApp).
+
+{% embed url="https://codepen.io/tatum-devrel/pen/qBQgNWd" %}
+Try this feature
+{% endembed %}
+
+### Parameters
+
+The method requires two parameters:
+
+1. **`address`** (required): The Ethereum address of the account or contract whose balance you want to query.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`blockParameter`** (optional): The block number or block identifier to specify the point in time for which you want to query the balance.
+ * Example: `"latest"` or `"0x1"`
+
+#### Transaction Details
+
+For the purpose of this documentation, we'll also describe the `transactions` field of a full transaction object. The `eth_getBalance` method does not return transaction details, but we provide this information for completeness.
+
+A full transaction object includes the following fields:
+
+* **`hash`**: The transaction hash.
+* **`nonce`**: The number of transactions made by the sender prior to this one.
+* **`blockHash`**: The hash of the block in which the transaction was included.
+* **`blockNumber`**: The block number in which the transaction was included.
+* **`transactionIndex`**: The index of the transaction in the block.
+* **`from`**: The sender's address.
+* **`to`**: The recipient's address (or `null` for contract creation transactions).
+* **`value`**: The value transferred, in wei.
+* **`gasPrice`**: The gas price provided by the sender, in wei.
+* **`gas`**: The maximum gas allowed for the transaction.
+* **`input`**: The data sent with the transaction (typically for contract interaction).
+* **`v`**, **`r`**, **`s`**: The raw signature values of the transaction.
+
+### Return Object
+
+The method returns a single field:
+
+* `result`: The Ether balance of the specified address in wei, as a hexadecimal string.
+ * Example: `"0x1a2e1a"`, which corresponds to `1,726,666` wei.
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBalance",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1a2e1a"
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblockbyhash.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblockbyhash.md
new file mode 100644
index 0000000..a779c28
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblockbyhash.md
@@ -0,0 +1,148 @@
+# eth\_getBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const block = await tatum.rpc.getBlockByHash('0x75e58e08a9f3a23bac9788d5077a9365abb5c29ec1aab70891264051624720af', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByHash` is an Ethereum JSON-RPC method that allows developers to query a specific block in the Ethereum blockchain by its block hash. This method can be used in various scenarios, such as analysing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/xxQNNGq" %}
+
+### Parameters
+
+The `eth_getBlockByHash` method accepts two parameters:
+
+1. **`blockHash`**: The hash of the block you want to retrieve information about.
+ * Type: `String`
+ * Example: `"0x75e58e08a9f3a23bac9788d5077a9365abb5c29ec1aab70891264051624720af"`
+2. **`fullTransactionDetails`**: A boolean value indicating whether to return full transaction details or just transaction hashes.
+ * Type: `Boolean`
+ * Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByHash",
+ "params": ["0x75e58e08a9f3a23bac9788d5077a9365abb5c29ec1aab70891264051624720af", true],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "baseFeePerGas": "0x35ddd12aa",
+ "difficulty": "0x0",
+ "extraData": "0xd883010c02846765746888676f312e32302e37856c696e7578",
+ "gasLimit": "0x1c9c380",
+ "gasUsed": "0x9426f0",
+ "hash": "0x75e58e08a9f3a23bac9788d5077a9365abb5c29ec1aab70891264051624720af",
+ "logsBloom": "0x2734882843000e08f2096070f803a2a854304d0062c40102d01b1002478401820020904c234830800d100600018509900b0022029b0c2e949e95c000153e008250005a18b42888380b00423a590113e611192c2c2144081308321ccdfbe004e40b805841b24a91041e0ddc1630466d0800584d1400181e2482444cd0aa6b025423218b052b405824464e88584013849102801e8109a6862d26010a64289348858a28c0078382eb808e4600a631b09660437a04354c5290822c448400020a09104d94a7e320438530080060201e3a05c431a0c4184aed32140d5d3093584d611e1991600a034148c05f0c443c2a0208086a22d1c1cb689049900ab0114010c202",
+ "miner": "0xb79743c0968c49a518be9c83bed8f6f69e005c32",
+ "mixHash": "0x5781d7db87a40a3301d673155ae8d2faa5a87c72dabc4a82fb944175cac5cf59",
+ "nonce": "0x0000000000000000",
+ "number": "0x1143497",
+ "parentHash": "0x41f676300e43cc244d5427b3714a5fc7146e443504c437b1f5bc4b337a06ae2a",
+ "receiptsRoot": "0xd6c87dabf0ec502567a85c32e77051d83f08b7627f4ed7d85e194eeb1d2b9b54",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x3ef6a",
+ "stateRoot": "0x4e6df5a0f0181b146d1ff137a7548ab3d67630011f6ea9ea084b9325dda56ff5",
+ "timestamp": "0x64fcddfb",
+ "totalDifficulty": "0xc70d815d562d3cfa955",
+ "transactions": [
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object], [Object],
+ [Object], [Object], [Object], [Object]
+ ],
+ "transactionsRoot": "0xbe9ed26c6b185a4b6d0b175ba694c9243eb58d06e11aff3258f5167d4ace26e7",
+ "uncles": [],
+ "withdrawals": [
+ [Object], [Object],
+ [Object], [Object],
+ [Object], [Object],
+ [Object], [Object],
+ [Object], [Object],
+ [Object], [Object],
+ [Object], [Object],
+ [Object], [Object]
+ ],
+ "withdrawalsRoot": "0x365326ed6795e450a8f437c7c30da68254567bbaf755321b2663dcc6777fddcb"
+ }
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblockbynumber.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblockbynumber.md
new file mode 100644
index 0000000..01edee9
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblockbynumber.md
@@ -0,0 +1,139 @@
+# eth\_getBlockByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const block = await tatum.rpc.getBlockByNumber('latest', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByNumber` is an Ethereum JSON-RPC method that allows developers to query a specific block in the Ethereum blockchain by its block number. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/qBQGwer" %}
+
+### Parameters
+
+There are two required parameters for this method:
+
+1. **`blockNumber`** - The block number of the block to be retrieved. This can be a hexadecimal string or one of the predefined aliases: `"earliest"`, `"latest"`, or `"pending"`.
+
+ Example: `"0x1b4"`
+2. **`returnFullTransactionObjects`** - A boolean value that determines whether the returned block contains complete transaction objects (`true`) or only transaction hashes (`false`).
+
+ Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByNumber",
+ "params": ["latest", true]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
new file mode 100644
index 0000000..ef1bc16
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
@@ -0,0 +1,70 @@
+# eth\_getBlockTransactionCountByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const response = await tatum.rpc.getBlockTransactionCountByHash('0x2907402477167193008a0cbbaa8073278c48e8b97bf9ed1a2101f6ad2130dbaf')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockTransactionCountByHash` is an Ethereum RPC method used to fetch the number of transactions in a block by the block's hash. It is useful when you want to know the total number of transactions included in a specific block and don't want to retrieve the entire block data. This method can be used in various scenarios, such as monitoring the network activity or estimating transaction confirmation times.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/dyQEEqj" %}
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`blockHash`**: The hash of the target block for which the transaction count will be retrieved. It should be a valid 32-byte hex string.
+
+Example of the parameter:
+
+* `blockHash`: `"0x2907402477167193008a0cbbaa8073278c48e8b97bf9ed1a2101f6ad2130dbaf"`
+
+### Return
+
+The method returns a single value:
+
+* `transactionCount`: The total number of transactions included in the specified block. It is returned as a hexadecimal value.
+
+### Examples
+
+#### JSON-RPC request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockTransactionCountByHash",
+ "params": [
+ "0x2907402477167193008a0cbbaa8073278c48e8b97bf9ed1a2101f6ad2130dbaf"
+ ]
+}
+```
+
+#### JSON-RPC response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x86"
+}
+```
+
+In this example, the block with the hash `"0x2907402477167193008a0cbbaa8073278c48e8b97bf9ed1a2101f6ad2130dbaf"` has a total of 134 transactions (indicated by the hexadecimal value `"0x86"`).
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
new file mode 100644
index 0000000..13bd04b
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
@@ -0,0 +1,65 @@
+# eth\_getBlockTransactionCountByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const response = await tatum.rpc.getBlockTransactionCountByNumber(17884144)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBlockTransactionCountByNumber` Ethereum JSON-RPC method allows you to retrieve the number of transactions in a specified block. This method is particularly useful when you need to analyze the transaction activity of a specific block. You can use it to gain insights into network usage, analyze the impact of specific events on the Ethereum network, or monitor transaction congestion in certain blocks.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/WNYBBBr" %}
+
+### Parameters
+
+1. **`blockNumber`**: The block number for which the transaction count should be retrieved. It should be a hex-encoded value representing the block number.
+ * Example: block number 17884144
+
+### Return Object
+
+The return object is a hex-encoded value representing the number of transactions in the specified block.
+
+* Example: 17884144 (10 transactions)
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBlockTransactionCountByNumber",
+ "params": [17884144]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x86"
+}
+```
+
+
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getcode.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getcode.md
new file mode 100644
index 0000000..8873541
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getcode.md
@@ -0,0 +1,78 @@
+# eth\_getCode
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const code = await tatum.rpc.getCode('0x742d35Cc6634C0532925a3b844Bc454e4438f44e')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getCode` method is part of the Ethereum JSON-RPC API, which allows users to interact with the Ethereum blockchain. This method is specifically used to retrieve the contract code (bytecode) of an account at a specific block number. It is helpful when developers need to examine the bytecode of a deployed contract or validate that the contract code on the blockchain matches the intended code.
+
+Use cases for this method could include:
+
+* Debugging a smart contract
+* Verifying the integrity of a deployed contract
+* Analyzing contract bytecode for security vulnerabilities
+
+{% embed url="https://codepen.io/tatum-devrel/pen/wvQbbmV" %}
+
+### Parameters
+
+The `eth_getCode` method accepts two parameters:
+
+1. **`address`** (string): The address of the contract whose bytecode you want to retrieve. This should be a 20-byte Ethereum address, formatted as a hex string with a `0x` prefix.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`block`** (string): The block number at which you want to retrieve the contract code. This can be specified as a hex string or one of the following special keywords:
+ * `"earliest"`: The first block in the blockchain
+ * `"latest"`: The most recent block in the blockchain
+ * `"pending"`: The upcoming block that is being mined
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The `eth_getCode` method returns a string representing the contract bytecode. The returned value is a hex string with a `0x` prefix.
+
+* If the account has contract code, the returned string will contain the bytecode.
+* If the account is not a contract or does not exist, the returned string will be `0x`.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getCode",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x606060...code_here...3839"
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getlogs.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getlogs.md
new file mode 100644
index 0000000..3df8114
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getlogs.md
@@ -0,0 +1,113 @@
+# eth\_getLogs
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const logs = await tatum.rpc.getLogs({ address : '0x742d35Cc6634C0532925a3b844Bc454e4438f44e'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getLogs` method is an Ethereum JSON-RPC method that allows developers to query logs generated by the Ethereum network, specifically event logs emitted by smart contracts. These logs are an essential part of the Ethereum ecosystem as they provide a way for developers to monitor contract events and track contract state changes.
+
+This method is particularly useful when building decentralized applications (dApps) that rely on events emitted by smart contracts, as it enables developers to retrieve logs based on specific filter criteria. By using `eth_getLogs`, developers can efficiently track and react to events happening on the Ethereum blockchain.\\
+
+{% embed url="https://codepen.io/tatum-devrel/pen/jOQooBO" %}
+
+### Parameters
+
+The `eth_getLogs` method takes a single input parameter: an object containing the filter criteria. The filter object can have the following fields:
+
+* **`fromBlock`**: (optional) The starting block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"fromBlock": "0x1"`
+* **`toBlock`**: (optional) The ending block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"toBlock": "0x2"`
+* **`address`**: (optional) The address or list of addresses of the contracts to filter logs from. Can be a single address or an array of addresses.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`topics`**: (optional) An array of up to four 32-byte topics. Topics are order-dependent, and each topic can be an array of topic hashes or `null`.
+ * Example: `"topics": ["0x123..."]`
+* **`blockhash`**: (optional) The block hash to filter logs from. If provided, `fromBlock` and `toBlock` are ignored.
+ * Example: `"blockhash": "0xc6ef9..."`
+
+In addition to the above fields, the `transactions` field in the filter object can be specified to include full transaction details instead of just transaction hashes. This is useful when you need more information about the transactions in which the events were emitted.
+
+### Return Object
+
+The `eth_getLogs` method returns an array of log objects. Each log object contains the following fields:
+
+* **`removed`**: A boolean indicating whether the log was removed due to a chain reorganization.
+ * Example: `"removed": false`
+* **`logIndex`**: The log index position in the block.
+ * Example: `"logIndex": "0x1"`
+* **`transactionIndex`**: The transaction index position in the block.
+ * Example: `"transactionIndex": "0x0"`
+* **`transactionHash`**: The hash of the transaction that emitted the log.
+ * Example: `"transactionHash": "0x88eef..."`
+* **`blockHash`**: The hash of the block containing the log.
+ * Example: `"blockHash": "0xc6ef9..."`
+* **`blockNumber`**: The block number containing the log.
+ * Example: `"blockNumber": "0x1"`
+* **`address`**: The address of the contract that emitted the log.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`data`**: The data associated with the log.
+ * Example: `"data":"0x0000000000000000000000000000000000000000000000000000000000000020"`
+* **`topics`**: An array of topics (order-dependent) associated with the log.
+ * Example: `"topics": ["0x123..."]`
+
+## JSON-RPC Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getLogs",
+ "params": [
+ {
+ "fromBlock": "0x1",
+ "toBlock": "0x2",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "removed": false,
+ "logIndex": "0x1",
+ "transactionIndex": "0x0",
+ "transactionHash": "0x88eef...",
+ "blockHash": "0xc6ef9...",
+ "blockNumber": "0x1",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "data": "0x0000000000000000000000000000000000000000000000000000000000000020",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+This documentation provides a comprehensive overview of the `eth_getLogs` Ethereum JSON-RPC method, its parameters, return objects, and JSON-RPC examples. By using this method, developers can effectively query logs generated by the Ethereum network and use the retrieved data to track and react to events happening on the Ethereum blockchain.
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getproof.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getproof.md
new file mode 100644
index 0000000..8543d16
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getproof.md
@@ -0,0 +1,111 @@
+# eth\_getProof
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.getProof("0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+ "latest")
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getProof` is an Ethereum JSON-RPC method that retrieves the Merkle-Patricia proof for an account, storage key-value pairs, and account transaction count. It allows developers to verify the state of an account or storage value at a specific block without needing the entire Ethereum state trie. This method is particularly useful for light clients or off-chain applications that require proof of an account's state or specific storage values.
+
+
+
+{% embed url="https://codepen.io/tatum-devrel/pen/GRwabgV" %}
+
+### Parameters
+
+1. **`address`** - `Data`, 20 Bytes
+ * The address of the account.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`keys`** - `Array` of `Data`
+ * An array of storage keys for which the proof should be generated.
+ * Example: `["0x0000000000000000000000000000000000000000000000000000000000000000"]`
+3. **`blockNumber`** - `Quantity` or `String`
+ * The block number for which the proof should be generated.
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+1. **`accountProof`** - `Array` of `Data`
+ * The serialized Merkle-Patricia proof for the account.
+2. **`balance`** - `Quantity`
+ * The balance of the account at the specified block.
+3. **`codeHash`** - `Data`, 32 Bytes
+ * The hash of the code for the account at the specified block.
+4. **`nonce`** - `Quantity`
+ * The transaction count of the account at the specified block.
+5. **`storageProof`** - `Array` of `Object`
+ * An array of storage proof objects, one for each requested key, containing the following fields:
+ * `key` - `Data`, 32 Bytes: The storage key.
+ * `value` - `Quantity`: The storage value.
+ * `proof` - `Array` of `Data`: The serialized Merkle-Patricia proof for the key-value pair.
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getProof",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ [
+ "0x0000000000000000000000000000000000000000000000000000000000000000"
+ ],
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": {
+ "accountProof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ],
+ "balance": "0xde0b6b3a7640000",
+ "codeHash": "0x...",
+ "nonce": "0x1",
+ "storageProof": [
+ {
+ "key": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "value": "0xde0b6b3a7640000",
+ "proof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ]
+ }
+ ]
+ }
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getstorageat.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getstorageat.md
new file mode 100644
index 0000000..4ee3cc5
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getstorageat.md
@@ -0,0 +1,71 @@
+# eth\_getStorageAt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const response = await tatum.rpc.getStorageAt('0x742d35Cc6634C0532925a3b844Bc454e4438f44e', '0x0')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getStorageAt` is an Ethereum JSON-RPC method that allows you to query the storage value of a contract at a given position. It can be used to inspect the internal state of a smart contract. This method is particularly useful for developers, auditors, and analysts who want to examine contract storage values for various purposes, such as debugging, verifying contract behavior, or analyzing data.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/jOQoojM?editors=1111" %}
+
+### Parameters
+
+`eth_getStorageAt` accepts three parameters:
+
+1. **`address`**: The address of the contract you want to query.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`position`**: The storage position (slot) you want to query.
+ * Example: `"0x0"`
+3. **`blockParameter`**: The block number, block hash, or one of the string literals (`"earliest"`, `"latest"` or `"pending"`), representing the point in the blockchain to query the storage value.
+ * Example: `"latest"`
+
+### Return Object
+
+The return object is a single string value, representing the storage value at the given position in the contract.
+
+* `result`: The storage value in a 32-byte (64 character) hexadecimal format.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getStorageAt",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "0x0",
+ "latest"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x0000000000000000000000000000000000000000000000000000000000000123"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
new file mode 100644
index 0000000..a5aab08
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
@@ -0,0 +1,105 @@
+# eth\_getTransactionByBlockHashAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const tx = await tatum.rpc.getTransactionByBlockHashAndIndex('0x2907402477167193008a0cbbaa8073278c48e8b97bf9ed1a2101f6ad2130dbaf', 1)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an Ethereum JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+{% embed url="https://codepen.io/tatum-devrel/pen/jOQojOV" %}
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockHash` (required): The hash of the block containing the transaction.
+ * Example: `"0x2907402477167193008a0cbbaa8073278c48e8b97bf9ed1a2101f6ad2130dbaf"`
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a hexadecimal value.
+ * Example: `"0x1"`
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockHashAndIndex",
+ "params": [
+ "0x2907402477167193008a0cbbaa8073278c48e8b97bf9ed1a2101f6ad2130dbaf",
+ "0x1"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x2907402477167193008a0cbbaa8073278c48e8b97bf9ed1a2101f6ad2130dbaf",
+ "blockNumber": "0x110e3f0",
+ "from": "0xcfdda03e6167ad55392c03d962a9da1bec513a23",
+ "gas": "0x39dca",
+ "gasPrice": "0x4601d234d",
+ "maxFeePerGas": "0x51cad3075",
+ "maxPriorityFeePerGas": "0x2faf080",
+ "hash": "0x9272e601263cf89cc3b5d65d33f8d708f9eb547b8d0d419cc0646361a8c8cca2",
+ "input": "0x3593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000064d4cec300000000000000000000000000000000000000000000000000000000000000020b0800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000085347052c302c70f700000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000008c130499d33097d4d000d3332e1672f75b431543",
+ "nonce": "0x29",
+ "to": "0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad",
+ "transactionIndex": "0x1",
+ "value": "0xde0b6b3a7640000",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0x1",
+ "v": "0x1",
+ "r": "0x6e3b191997b04e9b58bc2ada242830a6445ab233ea0971a53f9eceed7850cbfd",
+ "s": "0x4cd69316c2f5e54d48df588f03d527904e7300ee4477dfaca436844ecb11cbd1",
+ "yParity": "0x1"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
new file mode 100644
index 0000000..60e48b4
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
@@ -0,0 +1,101 @@
+# eth\_getTransactionByBlockNumberAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const tx = await tatum.rpc.getTransactionByBlockNumberAndIndex(10123321, 0)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an Ethereum JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+{% embed url="https://codepen.io/tatum-devrel/pen/RwqvRNp" %}
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockNumber` (required): either hexadecimal or decimal value
+ * Example: 10123321
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a hexadecimal or decimal value.
+ * Example: 0
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockNumberAndIndex",
+ "params": [
+ 10123321,
+ 0
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x103eca282ca064902fa3e15ad705bcf52cff6a5d0e9ad7b077a503268f6aa317",
+ "blockNumber": "0x9a7839",
+ "from": "0xcabda7c04a240498636ee0e535e0596b504c66d2",
+ "gas": "0x5208",
+ "gasPrice": "0xfd51da9a3",
+ "hash": "0x93f11750429ae0f792a584b0dca215c52c40b506086ceb16fb3200932939116f",
+ "input": "0x",
+ "nonce": "0x22e4",
+ "to": "0x3cd76d4a67ebd1c88cd8cf613c4551199cccae4d",
+ "transactionIndex": "0x0",
+ "value": "0x46bdf53e068dc0000",
+ "type": "0x0",
+ "v": "0x1c",
+ "r": "0x3a7ae13274733eac63e388a0f95568122431134ccbb1f408eedd4f3a579263a0",
+ "s": "0x5362b2ad9c89e8c0be551a81b77945090351482abe30592f28ae869ff87ad1c5"
+ }
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionbyhash.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionbyhash.md
new file mode 100644
index 0000000..68dcbe1
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionbyhash.md
@@ -0,0 +1,98 @@
+# eth\_getTransactionByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const tx = await tatum.rpc.getTransactionByHash('0x97696c2014695e851d85a344cbbc6ae8ab9d386de05cb0230fe50b91c044639b')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByHash` is an Ethereum JSON-RPC method that allows you to query transaction details based on its hash. This method is useful when you want to retrieve information about a specific transaction, such as its sender, receiver, value, and more. Common use cases include tracking transaction status, monitoring incoming transactions, or analyzing historical transaction data.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/qBQgZYe" %}
+
+### Parameters
+
+The `eth_getTransactionByHash` method takes one parameter:
+
+* **`transactionHash`**: The hash of the transaction you want to retrieve. This should be a 32-byte hash string with a `0x` prefix.
+ * Example: `"0x97696c2014695e851d85a344cbbc6ae8ab9d386de05cb0230fe50b91c044639b"`
+
+### Return Object
+
+The method returns a transaction object with the following fields:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getTransactionByHash",
+ "params": ["0x97696c2014695e851d85a344cbbc6ae8ab9d386de05cb0230fe50b91c044639b"],
+ "id": 1
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0xd1d718c5aef254e044928c1afeffd1c62e8c8566075b4ce70102a0185f15fe5b",
+ "blockNumber": "0x1149605",
+ "from": "0x0712663d09c8da4fdaa43d3ebd87a03c14ca9a5a",
+ "gas": "0x7b0c",
+ "gasPrice": "0x75de7040b",
+ "maxFeePerGas": "0x93e78c23c",
+ "maxPriorityFeePerGas": "0x828f156",
+ "hash": "0x97696c2014695e851d85a344cbbc6ae8ab9d386de05cb0230fe50b91c044639b",
+ "input": "0x",
+ "nonce": "0x21b",
+ "to": "0x698f26578e9955e0ef9f849a778feeadf43658ac",
+ "transactionIndex": "0x39",
+ "value": "0x20c0677f05ec0000",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0x1",
+ "v": "0x0",
+ "r": "0xbe80603b27d91a8d311cc0ab02b549b378f497f71068d84abab2a81c43a3a586",
+ "s": "0xb0d6771b3a0d3ba57f68b061f9841a9102a8bd8d9b62da4799b98cad0ce30",
+ "yParity": "0x0"
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactioncount.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactioncount.md
new file mode 100644
index 0000000..eabdd7e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactioncount.md
@@ -0,0 +1,76 @@
+# eth\_getTransactionCount
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.getTransactionCount('0x742d35Cc6634C0532925a3b844Bc454e4438f44e', 'pending')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getTransactionCount` method is an Ethereum JSON-RPC method that retrieves the number of transactions sent from a given address. It is a useful method for developers who need to keep track of an account's nonce value to avoid transaction collisions or incorrect order of execution. The nonce value is essential for ensuring transaction uniqueness and preventing replay attacks.
+
+Use cases for this method include:
+
+* Determining the nonce value for a new transaction to be sent from a specific address
+* Monitoring the number of transactions sent by an address to observe its activity
+* Troubleshooting transaction issues and verifying if a transaction was submitted successfully
+
+{% embed url="https://codepen.io/tatum-devrel/pen/LYXqZVG" %}
+
+### Parameters
+
+The `eth_getTransactionCount` method accepts two parameters:
+
+1. **`address`** - The Ethereum address whose transaction count will be retrieved.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`blockParameter`** - A string indicating the block number or block state to consider when retrieving the transaction count.
+ * Possible values: `"earliest"`, `"latest"`, `"pending"`, or a specific block number in hexadecimal format
+ * Example: `"latest"`
+
+### Return Object
+
+The method returns a single value:
+
+* **`transactionCount`** - A hexadecimal representation of the number of transactions sent from the specified address.
+ * Example: `"0x1e"`
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionCount",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1e"
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionreceipt.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionreceipt.md
new file mode 100644
index 0000000..2cd8799
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_gettransactionreceipt.md
@@ -0,0 +1,101 @@
+# eth\_getTransactionReceipt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const tx = await tatum.rpc.getTransactionReceipt('0x2a4811309750a84058d2fd1bd8dd534bf3a34039ff1b34e29f23a92dfb06449d')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionReceipt` is an Ethereum JSON-RPC method that retrieves the transaction receipt of a given transaction hash. This method is particularly useful when you need to obtain detailed information about a transaction's execution, such as its status (success or failure), gas usage, and logs (events). Common use cases include checking the status of a transaction after it has been mined or inspecting the events emitted by a smart contract during a specific transaction.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/QWJYNxa" %}
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`transactionHash`**: The hash of the transaction for which you want to obtain the receipt.
+ * Example: `"0x2a4811309750a84058d2fd1bd8dd534bf3a34039ff1b34e29f23a92dfb06449d"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+* **`transactionHash`**: The hash of the transaction.
+* **`transactionIndex`**: The transaction's index position in the block.
+* **`blockHash`**: The hash of the block where this transaction was mined.
+* **`blockNumber`**: The block number where this transaction was mined.
+* **`from`**: The address of the sender.
+* **`to`**: The address of the receiver. `null` when it's a contract creation transaction.
+* **`cumulativeGasUsed`**: The total amount of gas used when this transaction was executed in the block.
+* **`gasUsed`**: The amount of gas used by this specific transaction alone.
+* **`contractAddress`**: The address of the contract created, if the transaction was a contract creation. Otherwise, `null`.
+* **`logs`**: An array of log objects, which were emitted during the transaction.
+* **`logsBloom`**: A 256-byte bloom filter, which is a compressed representation of the logs emitted during the transaction.
+* **`status`**: The status of the transaction's execution. `"0x1"` indicates success, while `"0x0"` indicates failure.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionReceipt",
+ "params": [
+ "0x2a4811309750a84058d2fd1bd8dd534bf3a34039ff1b34e29f23a92dfb06449d"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x75e58e08a9f3a23bac9788d5077a9365abb5c29ec1aab70891264051624720af",
+ "blockNumber": "0x1143497",
+ "contractAddress": null,
+ "cumulativeGasUsed": "0x9382e0",
+ "effectiveGasPrice": "0x35ef89748",
+ "from": "0x2b862fe79a56419979e97b95f910b93f6d338e33",
+ "gasUsed": "0x2b7fe",
+ "logs": [
+ [Object],
+ [Object],
+ [Object],
+ [Object],
+ [Object],
+ [Object]
+ ],
+ "logsBloom": "0x0..."
+ "status": "0x1",
+ "to": "0xb517850510997a34b4ddc8c3797b4f83fad510c4",
+ "transactionHash": "0x2a4811309750a84058d2fd1bd8dd534bf3a34039ff1b34e29f23a92dfb06449d",
+ "transactionIndex": "0x4c",
+ "type": "0x2"
+ }
+}
+
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getunclecountbyblockhash.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
new file mode 100644
index 0000000..255d796
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
@@ -0,0 +1,74 @@
+# eth\_getUncleCountByBlockHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.getUncleCountByBlockHash('0x827d30e914a3adeefabb9d53f70da87e6e0ed3d02a72e7d9ae9bfd1bf123c7a3')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an Ethereum JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the Ethereum network and to analyse the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralisation of the Ethereum network. The inclusion of uncles helps prevent centralisation and ensures the mining process remains competitive.
+
+
+
+{% embed url="https://codepen.io/Jan-Musil-the-lessful/pen/NWEJRvZ" %}
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockHash`: The hash of the block for which you want to get the uncle count.
+ * Example value: `"0x827d30e914a3adeefabb9d53f70da87e6e0ed3d02a72e7d9ae9bfd1bf123c7a3"`
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockHash` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockHash",
+ "params": [
+ "0x827d30e914a3adeefabb9d53f70da87e6e0ed3d02a72e7d9ae9bfd1bf123c7a3"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x1"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
new file mode 100644
index 0000000..d3d6a0d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
@@ -0,0 +1,73 @@
+# eth\_getUncleCountByBlockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const result = await tatum.rpc.getUncleCountByBlockNumber(15537345)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an Ethereum JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the Ethereum network and to analyse the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralisation of the Ethereum network. The inclusion of uncles helps prevent centralisation and ensures the mining process remains competitive.
+
+{% embed url="https://codepen.io/Jan-Musil-the-lessful/pen/vYQPXer" %}
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockNumber`: The number of the block for which you want to get the uncle count.
+ * Example value: 15537345
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockNumber` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockNumber",
+ "params": [
+ "0xED14C1"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x1"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/README.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/README.md
new file mode 100644
index 0000000..1b1ccbc
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/README.md
@@ -0,0 +1,2 @@
+# Transaction
+
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_estimategas.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_estimategas.md
new file mode 100644
index 0000000..c31ee3e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_estimategas.md
@@ -0,0 +1,94 @@
+# eth\_estimateGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const estimate = await tatum.rpc.estimateGas({
+ "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060"
+ })
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_estimateGas` is an Ethereum JSON-RPC method that estimates the amount of gas required to execute a given transaction. This method can be used to determine the gas cost before sending a transaction, allowing developers to better predict the gas fees and avoid issues like out-of-gas errors.
+
+Use cases for `eth_estimateGas` include:
+
+* Estimating gas costs for contract deployments
+* Estimating gas costs for contract function calls
+* Estimating gas costs for standard ether transfers
+
+{% embed url="https://codepen.io/tatum-devrel/pen/KKrJMNb" %}
+
+### Parameters
+
+The `eth_estimateGas` method takes a single parameter, an object representing the transaction details. The fields in the transaction object include:
+
+* **`from`** (optional, string): The address that the transaction is sent from.
+ * Example: `"from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`to`** (optional, string): The address the transaction is sent to.
+ * Example: `"to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`gas`** (optional, string): The maximum amount of gas provided for the transaction.
+ * Example: `"gas": "0x76c0"`
+* **`gasPrice`** (optional, string): The price of gas in wei.
+ * Example: `"gasPrice": "0x9184e72a000"`
+* **`value`** (optional, string): The amount of ether to send in the transaction, in wei.
+ * Example: `"value": "0xde0b6b3a7640000"`
+* **`data`** (optional, string): The data payload of the transaction, typically used for contract function calls or contract deployment.
+ * Example: `"data": "0x606060..."`
+* **`nonce`** (optional, string): The transaction count of the `from` address.
+ * Example: `"nonce": "0x1"`
+
+### Return Object
+
+The return value of the `eth_estimateGas` method is a single field:
+
+* `gasEstimate` (string): The estimated gas cost for the transaction, represented as a hexadecimal string.
+ * Example: `"0x5208"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_estimateGas",
+ "params": [
+ {
+ "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060..."
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x5208"
+}
+```
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_gasprice.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_gasprice.md
new file mode 100644
index 0000000..3808eeb
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_gasprice.md
@@ -0,0 +1,62 @@
+# eth\_gasPrice
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const gasPrice = await tatum.rpc.gasPrice()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_gasPrice` method is an Ethereum JSON-RPC method used to estimate the average gas price required for transactions in the Ethereum network. This method provides a suggestion for the gas price to be used in a transaction to increase the likelihood of it being mined and included in a block in a reasonable amount of time. The `eth_gasPrice` method is particularly useful for developers and users who want to create and send transactions, as it helps them estimate the appropriate gas price to ensure timely processing.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/ExOryZa" %}
+
+### Parameters
+
+The `eth_gasPrice` method does not require any parameters.
+
+### Return Value
+
+The `eth_gasPrice` method returns a single value as a hexadecimal string:
+
+* `gasPrice`: The estimated average gas price in wei. Example: `"0x4a817c800"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_gasPrice",
+ "params": []
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4a817c800"
+}
+```
+
+By using the `eth_gasPrice` method, developers and users can estimate the appropriate gas price for their transactions, improving the overall user experience and ensuring that their transactions are processed in a timely manner.
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_maxpriorityfeepergas.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
new file mode 100644
index 0000000..4e64c4e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
@@ -0,0 +1,64 @@
+# eth\_maxPriorityFeePerGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const gasPrice = await tatum.rpc.maxPriorityFeePerGas()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_maxPriorityFeePerGas` RPC method is used to retrieve the maximum priority fee per gas set by the user for a transaction. This method can be used to determine the maximum fee that can be paid for a transaction to be included in a block quickly.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/gOQqMgX" %}
+
+### Use case
+
+This method is particularly useful when the user wants to ensure that a transaction is processed quickly, even in a congested network where transaction fees may fluctuate rapidly. By setting a high maximum priority fee per gas, the user can ensure that the transaction is processed as quickly as possible.
+
+### Parameters
+
+`None.`
+
+## Return Object
+
+* `maxPriorityFeePerGas` - The maximum priority fee per gas the user is willing to pay, in wei.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_maxPriorityFeePerGas",
+ "params": [],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x3b9aca00"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_sendrawtransaction.md b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_sendrawtransaction.md
new file mode 100644
index 0000000..334bee5
--- /dev/null
+++ b/docs/rpc/evm-blockchains/ethereum-rpc-documentation/transaction/eth_sendrawtransaction.md
@@ -0,0 +1,62 @@
+# eth\_sendRawTransaction
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Ethereum, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.ETHEREUM})
+
+const gasPrice = await tatum.rpc.sendRawTransaction('0x0000.......')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_sendRawTransaction` RPC method is used to send a signed and serialized Ethereum transaction to the network. This method is particularly useful when you want to have full control over the signing process, e.g., when using hardware wallets, cold storage, or custom signing libraries. It can be utilized in various use cases, such as transferring Ether, interacting with smart contracts, or deploying new contracts.
+
+### Parameters
+
+The method accepts a single parameter:
+
+* **`data`**: The signed and serialized transaction data as a hexadecimal string.
+
+### Return Value
+
+The method returns a single value:
+
+* `transactionHash`: The hash of the submitted transaction as a hexadecimal string, e.g., `"0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"`.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_sendRawTransaction",
+ "params": [
+ "0xf86d8201...94a7bc"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/README.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/README.md
new file mode 100644
index 0000000..e2b74f5
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/README.md
@@ -0,0 +1,3 @@
+# Flare RPC documentation
+
+Flare RPC (Remote Procedure Call) is a powerful tool for interacting with the Flare blockchain network. It provides developers with a standardised interface to communicate with the Flare network, enabling them to retrieve data, send transactions, deploy smart contracts, and more. With Flare RPC, developers can build decentralised applications, integrate blockchain functionality into existing systems, and explore the vast ecosystem of Flare.
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/README.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/README.md
new file mode 100644
index 0000000..1fb947d
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/README.md
@@ -0,0 +1,2 @@
+# Archival information
+
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_getbadblocks.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_getbadblocks.md
new file mode 100644
index 0000000..4786892
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_getbadblocks.md
@@ -0,0 +1,99 @@
+# debug\_getBadBlocks
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.debugGetBadBlocks()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_getBadBlocks` is an RPC method that provides a list of the most recent bad blocks encountered by the client on the network. This feature is valuable for developers and node operators, as it enables them to identify and address any issues or anomalies related to block validation and synchronization.
+
+By accessing `debug_getBadBlocks`, they can diagnose potential problems and take appropriate actions to ensure the network's stability and integrity.
+
+### Parameters
+
+* This method does not accept any parameters.
+
+### Return Object
+
+The output is an array of objects, with each object representing the trace result of a transaction within the block. These objects include essential details such as the transaction hash and a block object, which can be null if no block was found for the transaction:
+
+* `baseFeePerGas`: The integer representation of the difficulty for this block encoded as hexadecimal.
+* `difficulty`: The integer representation of the difficulty for this block encoded as hexadecimal.
+* `extraData`: The extra data field of this block.
+* `gasLimit`: The maximum gas allowed in this block encoded as hexadecimal.
+* `gasUsed`: The total used gas by all transactions in this block encoded as hexadecimal.
+* `logsBloom`: The bloom filter for the logs of the block. Null if pending.
+* `miner`: The address of the beneficiary to whom the mining rewards were given.
+* `mixHash`: A 256-bit hash encoded as hexadecimal.
+* nonce: The hash of the generated proof-of-work. Null if pending.
+* `number`: The block number of the requested block encoded as hexadecimal. Null if pending.
+* `parentHash`: The hash of the parent block.
+* `receiptsRoot`: The root of the receipts trie of the block.
+* `sha3Uncles`: The SHA3 of the uncles data in the block.
+* size: The size of this block in bytes as an Integer value encoded as hexadecimal.
+* `stateRoot`: The root of the final state trie of the block.
+* timestamp: The Unix timestamp for when the block was collated.
+* `transactions`: An array of transaction objects with the following fields:
+ * `blockHash`: The hash of the block where this log was in. Null when it's a pending log.
+ * `blockNumber`: The block number where this log was in. Null when it's a pending log.
+ * `from`: The address of the sender.
+ * `gas`: The gas provided by the sender, encoded as hexadecimal.
+ * `gasPrice`: The gas price provided by the sender in wei, encoded as hexadecimal.
+ * maxFeePerGas: The maximum fee per gas set in the transaction.
+ * `maxPriorityFeePerGas`: The maximum priority gas fee set in the transaction.
+ * hash: The hash of the transaction.
+ * `input`: The data sent along with the transaction.
+ * nonce: The number of transactions made by the sender before this one encoded as hexadecimal.
+ * `to`: The address of the receiver. Null when it's a contract creation transaction.
+ * `transactionIndex`: The integer of the transaction's index position that the log was created from. Null when it's a pending log.
+ * `value`: The value transferred in wei encoded as hexadecimal.
+ * `type`: The transaction type.
+ * `accessList`: A list of addresses and storage keys that the transaction plans to access.
+ * `chainId`: The chain id of the transaction, if any.
+* `transactionsRoot`: The root of the transaction trie of the block.
+* `uncles`: An array of uncle hashes.
+* `rlp`: The RLP encoded header.
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_getBadBlocks",
+ "params": []
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": []
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_storagerangeat.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_storagerangeat.md
new file mode 100644
index 0000000..f708ad9
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_storagerangeat.md
@@ -0,0 +1,84 @@
+# debug\_storageRangeAt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.debugStorageRangeAt(
+'0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d',
+1, '0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', '0x0', '0x64'
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_storageRangeAt` is an RPC method that allows you to retrieve the contract storage range for a given block and address. This can be useful for developers and auditors who want to inspect the storage state of a specific contract at a particular point in time. This method can also help in debugging and identifying potential issues with contract storage, as well as understanding how storage evolves as transactions are executed.
+
+### Parameters
+
+The `debug_storageRangeAt` method accepts the following parameters:
+
+* `blockHash`: The block hash for which the storage range should be retrieved. Example: `"0x3c4523b7e8c21e3d68f1c3af3d18e8a87c0d43e35b2c1b7f8f4e87e4d4db9c82"`
+* `txIndex`: The transaction index within the specified block. Example: 1
+* `address`: The contract address for which the storage range should be retrieved. Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* `begin`: The beginning of the storage range. Example: `"0x0"`
+* `end`: The end of the storage range. Example: `"0x64"` (inclusive)
+
+### Return Object
+
+The `debug_storageRangeAt` method returns an object with the following fields:
+
+* `storage`: An object that contains key-value pairs representing the contract storage, where the key is the storage slot and the value is the stored data. Example: `"0x00..01": "0x00..01"`
+* `nextKey`: A key indicating the next storage slot if the requested range is too large, otherwise `null`. Example: `"0x00..02"` or `null`
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "debug_storageRangeAt",
+ "params": [
+ "0x3c4523b7e8c21e3d68f1c3af3d18e8a87c0d43e35b2c1b7f8f4e87e4d4db9c82",
+ "0x1",
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "0x0",
+ "0x64"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "storage": {
+ "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000002"
+ },
+ "nextKey": "0x0000000000000000000000000000000000000000000000000000000000000065"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_traceblock.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_traceblock.md
new file mode 100644
index 0000000..250ee94
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_traceblock.md
@@ -0,0 +1,99 @@
+# debug\_traceBlock
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.debugTraceBlock('0xAD7C5E' ,{tracer:'callTracer'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlock` is an RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `debug_traceBlock`, developers can obtain detailed insights into the execution flow of each transaction, allowing for in-depth analysis and debugging
+
+### Parameters
+
+* `block` - `String`
+ * RLP encoded block object.
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer`: The tracer object with the following fields:
+ * `callTracer`: The calltracer keeps track of all call frames, including depth 0 calls, made during a transaction.
+ * `prestateTracer`: The prestateTracer replays the transaction and tracks every part of the state that occurred during the transaction.
+ * `tracerConfig`: The object to specify the configurations of the tracer.
+ * onlyTopCall: When set to true, it traces only the primary (top-level) call and not any sub-calls, eliminating additional processing for each call frame.
+
+### Return Object
+
+The return object is an array of all invoked opcodes of all transaction that were included in this block.
+
+* `type`: The type of the call.
+* `from`: The address from which the transaction is sent.
+* `to`: The address to which the transaction is directed.
+* `value`: The integer value sent with this transaction.
+* `gas`: The integer value of the gas provided for the transaction execution.
+* `gasUsed`: The integer value of the gas used.
+* `input`: The data given at the time of input.
+* `output`: The data returned as an output.
+* `calls`: A list of sub-calls made during the transaction, including detailed trace information for each sub-call.
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlock",
+ "params": [
+ "0x1dc....",
+ {
+ "tracer": "callTracer"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_traceblockbyhash.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_traceblockbyhash.md
new file mode 100644
index 0000000..5c8af50
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_traceblockbyhash.md
@@ -0,0 +1,106 @@
+# debug\_traceBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.debugTraceBlockByHash(
+'0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d',
+{tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlockByHash` is an Flare RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during each transaction, including the input, output, and depth of the calls.
+
+### Parameters
+
+* `block_hash` (required): The hash of the block to be traced.
+ * Example: `"0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an array of objects, each representing the trace result of a transaction within the block. Each object contains the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlockByHash",
+ "params": [
+ "0x1dcf337a03e08a8c00e31de6f5b6d9a6e1c6f1d5e5e6c89fc5f5b5a30e6d5d0c",
+ {
+ "tracer": "callTracer",
+ "timeout": "10s"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_traceblockbynumber.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_traceblockbynumber.md
new file mode 100644
index 0000000..5b50a41
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_traceblockbynumber.md
@@ -0,0 +1,104 @@
+# debug\_traceBlockByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.debugTraceBlockByNumber(12689342)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceBlockByNumber` is an Flare RPC method that allows developers to trace all transactions within a block using a given tracer. This is particularly useful for analyzing the behavior of all transactions in a block, investigating potential issues, and understanding the flow of execution within smart contracts.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during each transaction, including the input, output, and depth of the calls.
+
+### Parameters
+
+* `blockNumber` - `Quantity` or `String`
+ * The block number of the block to trace.
+ * Example: `"0x1"` or `"latest"`
+* `options` as `tracerConfig`(optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (required): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "10s"). Default is "5s".
+ * Example: `tracerConfig: { onlyTopCall: true, timeout: '10', }`
+
+### Return Object
+
+The return object is an array of objects, each representing the trace result of a transaction within the block. Each object contains the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "debug_traceBlockByNumber",
+ "params": [
+ "latest",
+ {
+ "tracer": "callTracer",
+ "timeout": "10s"
+ }
+ ]
+}
+
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "result": {
+ "from": "0x8894e0a0c962cb723c1976a4421c95949be2d4e3",
+ "gas": "0x2d48c",
+ "gasUsed": "0xc7ab",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0xa9059cbb0000000000000000000000003b9f33b3a9d382fa60283c555bde8f78855957be00000000000000000000000000000000000000000000000d4e7f4f79da7c0000",
+ "output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+ "value": "0x0",
+ "type": "CALL"
+ }
+ }
+ ]
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_tracecall.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_tracecall.md
new file mode 100644
index 0000000..332a371
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_tracecall.md
@@ -0,0 +1,119 @@
+# debug\_traceCall
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.debugTraceCall({
+ "from": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ "to": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e87",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0xAD7C5E",
+ {tracer:'callTracer'}
+)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceCall` is an Flare RPC method that allows you to execute a given call (message), tracing the steps of its execution. This can be helpful for developers and auditors who want to inspect and analyze the internal operations and state changes of a contract call without modifying the blockchain state. This method can assist in debugging and identifying potential issues with contract execution, as well as understanding how gas is consumed during the execution of a call.
+
+### Parameters
+
+The `debug_traceCall` method accepts the following parameters:
+
+* `transaction`: An object that contains the following fields:
+ * `from`: The address from which the call is initiated. Example: `"0xa7d9ddbe1f17865597fbd27ec712455208b6b76d"`
+ * `to`: The address of the contract to be called. Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+ * `gas`: (Optional) The gas limit for the call. Example: `"0x76c0"`
+ * `gasPrice`: (Optional) The gas price for the call. Example: `"0x9184e72a000"`
+ * `value`: (Optional) The value to be transferred during the call. Example: `"0x9184e72a"`
+ * `data`: (Optional) The input data for the call, encoded as a hexadecimal string. Example: `"0x606060..."`
+* `blockNumber`: The block number for which the call should be traced. Example: `"0x1b4"`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `output`: The output data from the call.
+* `gasUsed`: The total gas used by the call.
+* `calls`: An array of objects, each representing a nested call made during the call. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "debug_traceCall",
+ "params": [
+ {
+ "from": "0xa7d9ddbe1f17865597fbd27ec712455208b6b76d",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "gas": "0x76c0",
+ "gasPrice": "0x9184e72a000",
+ "value": "0x9184e72a",
+ "data": "0x606060..."
+ },
+ "0x1b4"
+ ]
+}
+
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_tracetransaction.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_tracetransaction.md
new file mode 100644
index 0000000..e07a578
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/archival-information/debug_tracetransaction.md
@@ -0,0 +1,102 @@
+# debug\_traceTransaction
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.debugTraceTransaction('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9', {tracer:'callTracer'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`debug_traceTransaction` is an Flare RPC method that allows developers to inspect and trace the execution of a specific transaction, providing valuable insight into the internal workings of the transaction, including the calls made between contracts, the state of the contracts, and any errors encountered during the transaction.
+
+By using the `callTracer` tracer, developers can obtain more detailed information about the calls made during the transaction, including the input, output, and the depth of the calls. This is particularly useful in debugging complex transactions, analyzing gas consumption, and understanding the flow of execution within smart contracts.
+
+### Parameters
+
+* `transaction_hash` (required): The hash of the transaction to trace.
+ * Example: `"0x123f681646d4a755815f9cb19e1acc8565a0c2ac"`
+* `options` (optional): An object containing configuration options for the tracer.
+ * `tracer` (required): The tracer to use, in this case, `"callTracer"`.
+ * `timeout` (optional): The maximum amount of time the tracer is allowed to run, in seconds or as a string (e.g. "5s" or "500ms"). Default is "5s".
+ * Example: `{"tracer": "callTracer", "timeout": "10s"}`
+
+### Return Object
+
+The return object is an object containing the following fields:
+
+* `from`: The address the transaction was sent from.
+* `gas`: The gas provided for the transaction.
+* `gasUsed`: The total gas used by the transaction.
+* `to`: The address the transaction was sent to.
+* `input`: The input data for the transaction.
+* `output`: The output data from the transaction.
+* `calls`: An array of objects, each representing a call made during the transaction. Each object contains:
+ * `from`: The address the call was made from.
+ * `gas`: The gas provided for the call.
+ * `gasUsed`: The gas used by the call.
+ * `to`: The address the call was made to.
+ * `input`: The input data for the call.
+ * `output`: The output data from the call.
+ * `type`: The type of the call (e.g., "STATICCALL").
+
+{% hint style="info" %}
+This method is available only on the full archive node.
+{% endhint %}
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "debug_traceTransaction",
+ "params": ["0x920d562e886a0c7c1f07ecee2ee5557f72d3056b205f8811c57e2615a3b6adb0", {"tracer":"callTracer"}],
+ "id": 2
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 2,
+ "result": {
+ "from": "0x0a6d033f6628ef715732d61e059187b7330305ff",
+ "gas": "0x51fba",
+ "gasUsed": "0x41711",
+ "to": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "input": "0xcba9bc66000000000000000000000000f62ef040fb5ea7d0828ff50bced9a7720f1387c7000000000000000000000000325e343f1de602396e256b67efd1f61c3a6b38bd00000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000001158e460913d000000000000000000000000000000000000000000000000000000100a08761e1547f0000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff000000000000000000000000000000000000000000000000000000000000000300000000000000000000000055d398326f99059ff775485246999027b319795500000000000000000000000053e562b9b7e5e94b81f10e96ee70ad06df3d265700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "output": "0x0000000000000000000000000000000000000000000000000102b1eda6a2682d",
+ "calls": [
+ {
+ "from": "0x19e870855cb8fd8f6689743d3c28311c0d62a24c",
+ "gas": "0x4f638",
+ "gasUsed": "0x4cf",
+ "to": "0x55d398326f99059ff775485246999027b3197955",
+ "input": "0x70a082310000000000000000000000000a6d033f6628ef715732d61e059187b7330305ff",
+ "output": "0x00000000000000000000000000000000000000000000002ca114a674b092dd94",
+ "type": "STATICCALL"
+ }
+ ],
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/README.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/README.md
new file mode 100644
index 0000000..563f334
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/README.md
@@ -0,0 +1,2 @@
+# Mempool
+
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool_content.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool_content.md
new file mode 100644
index 0000000..d66fcdf
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool_content.md
@@ -0,0 +1,129 @@
+# txpool\_content
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const content = await tatum.rpc.txPoolContent()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_content` method provides information about the transactions currently pending in the transaction pool of the Flare node. It can be helpful for developers and node operators to monitor and manage the transaction pool, especially in scenarios where it's necessary to analyze transaction congestion or prioritize specific transactions.
+
+Use cases for the `txpool_content` method include:
+
+* Analyzing network congestion by inspecting the transaction pool
+* Prioritizing transactions by gas price
+* Monitoring transactions from specific addresses
+* Debugging and troubleshooting pending transactions
+
+### Parameters
+
+This method does not require any parameters.
+
+### Return Object
+
+The `txpool_content` method returns an object with two fields: `pending` and `queued`. Each field contains a nested object with addresses as keys and their respective transactions as values.
+
+* **`pending`**: An object containing transactions that are currently pending for inclusion in the next block(s).
+* **`queued`**: An object containing transactions that are currently queued (i.e., transactions that do not meet certain criteria for inclusion in the next block, like low gas price or nonce gaps).
+
+Each transaction object includes the following information:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Request Example
+
+```json
+jsonCopy code{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "txpool_content",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x01d3b93aaade8a4066daabc8fd8482173a6ad120",
+ "gas": "0x1c9c380",
+ "gasPrice": "0x16cf917",
+ "maxFeePerGas": "0x16cf917",
+ "maxPriorityFeePerGas": "0x16cf917",
+ "hash": "0x1da9c2a8f0787bac4747c5ed1035e81f6a6745aeea43943e63635fc367b817f7",
+ "input": "0x00000000",
+ "nonce": "0xc5",
+ "to": "0x4f023eb8c6bc3116e35b67e03bf2c17f2e4f7e7e",
+ "transactionIndex": null,
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0x14f7578b57fd9f87acf5bbceb0a47f2d2d3f39b49169357457618c9634c45e8a",
+ "s": "0x775fa9976c571751a79f069f8c96f6489f286246e157a31fa99b33062631b46d"
+ }
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x03321406635a04d37cf9211f2ea3afc83a87e777",
+ "gas": "0x5208",
+ "gasPrice": "0xc570bd200",
+ "hash": "0x05f5fb8e46793fafdc924917c0afdd0afb4a53cb562542d5399234bc1eff759b",
+ "input": "0x",
+ "nonce": "0x4dc359",
+ "to": "0x77b1c86ab0aa9066803ed567e1f00973976638f6",
+ "transactionIndex": null,
+ "value": "0xb1a2b96602aa20",
+ "type": "0x0",
+ "chainId": "0xaa36a7",
+ "v": "0x1546d72",
+ "r": "0x62bd220b95ec13827c0d9b643b9beaf6f4c66d4a8ef08bb10f93d5e5c7ae0068",
+ "s": "0x467f76847cfdf43a002defe054030c1a88a9e6f56539c051c3cba46b2dd2cc89"
+ }
+ }
+ }
+ }
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool_inspect.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool_inspect.md
new file mode 100644
index 0000000..d489ef3
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool_inspect.md
@@ -0,0 +1,76 @@
+# txpool\_inspect
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const inspect = await tatum.rpc.txPoolInspect()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_inspect` method is a JSON-RPC method used to inspect the current transaction pool of a running Flare node. The method allows you to view all pending transactions and their details, including transaction hashes, gas prices, and transaction data. This method is useful for developers who want to monitor the status of pending transactions or debug transaction-related issues.
+
+### Parameters
+
+The `txpool_inspect` method takes one optional parameter:
+
+* **`include`**: A string specifying the type of transactions to include in the response. Possible values are **`pending`** (default) and **`queued`**.
+
+### Return Object
+
+The `txpool_inspect` method returns an object with the following fields:
+
+* **`pending`**: An array of transaction objects, with textual data
+* **`queued`**: An array of transaction objects, with textual data
+
+## Example Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "txpool_inspect",
+ "params": [
+ "pending"
+ ],
+ "id": 1
+}
+```
+
+## Example Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": "0x4f023eB8C6BC3116E35B67E03bf2C17f2e4f7e7e: 0 wei + 30000000 gas ร 23918871 wei"
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 49999988041886240 wei + 21000 gas ร 53000000000 wei",
+ "8308536": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 100000000000000000 wei + 21000 gas ร 53000000000 wei",
+ "231211221": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 1000000000000000 wei + 21000 gas ร 11958113760 wei"
+ }
+ }
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool_status.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool_status.md
new file mode 100644
index 0000000..8e674fe
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/mempool/txpool_status.md
@@ -0,0 +1,64 @@
+# txpool\_status
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const status = await tatum.rpc.txPoolStatus()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_status` method returns statistics about the current state of the transaction pool. The transaction pool is a queue of pending transactions waiting to be included in the next block by miners.
+
+This method can be useful for monitoring the health of the Flare network and analyzing the behavior of the miners. It can also be used to estimate the time it will take for a transaction to be processed, as well as to determine the gas price necessary to ensure prompt inclusion of a transaction in the next block.
+
+### Parameters
+
+This method does not take any parameters.
+
+### Return Object
+
+The `txpool_status` method returns an object with the following fields:
+
+* **`pending`**: Number of pending transactions in the pool
+* **`queued`**: Number of queued transactions in the pool
+
+### Example Request
+
+```json
+{
+ "jsonrpc":"2.0",
+ "method":"txpool_status",
+ "params":[],
+ "id":1
+}
+```
+
+### Example Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": 4,
+ "queued": 10
+ }
+}
+```
+
+In this example response, there are currently 4 pending transactions and 10 queued transactions waiting to be processed by miners.
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/README.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/README.md
new file mode 100644
index 0000000..bd96ae8
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/README.md
@@ -0,0 +1,2 @@
+# Network/Client information
+
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/eth_chainid.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/eth_chainid.md
new file mode 100644
index 0000000..0ab1df9
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/eth_chainid.md
@@ -0,0 +1,62 @@
+# eth\_chainId
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const id = await tatum.rpc.chainId()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_chainId` method is an Flare JSON-RPC method that allows developers to retrieve the currently configured chain ID of the Flare network they are connected to. The chain ID is a unique identifier for different Flare networks, such as Flare Mainnet or various testnets.
+
+This method is particularly useful when building applications that interact with multiple Flare networks or need to verify the network to prevent replay attacks. By checking the chain ID, an application can ensure it is interacting with the intended network.
+
+### Parameters
+
+The `eth_chainId` method does not have any input parameters.
+
+### Return Object
+
+The return object contains a single field:
+
+* **`chainId`**: The hexadecimal string representation of the chain ID.
+
+### Example Request and Response
+
+JSON-RPC request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_chainId",
+ "params": []
+}
+```
+
+JSON-RPC response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0xe"
+}
+```
+
+In this example, the returned chain ID is `0xe`, which corresponds to the Flare Mainnet.
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/web3_clientversion.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/web3_clientversion.md
new file mode 100644
index 0000000..3293df5
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-client-information/web3_clientversion.md
@@ -0,0 +1,64 @@
+# web3\_clientVersion
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const version = await tatum.rpc.clientVersion()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`web3_clientVersion` is a method of the Flare JSON-RPC API that allows the client to retrieve the current version of the Flare client software being used by the node.
+
+This method is read-only and does not require authentication. The `web3_clientVersion` method can be used by developers to confirm the version of the Flare client software they are using and ensure that it is compatible with their application.
+
+### Parameters
+
+This method has no parameters. It only retrieves the current version of the Flare client software.
+
+### Return Object
+
+The `web3_clientVersion` method returns a string representing the version of the Flare client software being used. The string includes the client name, version number, and build information.
+
+* `String` - Version string of the Flare client software being used.
+
+### Example Request
+
+#### JSON Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "web3_clientVersion",
+ "params": [],
+ "id": 1
+}
+```
+
+### Example Response
+
+#### JSON Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 67,
+ "result": "v0.8.15"
+}
+```
+
+In the above example, the Flare client software being used is in version 0.8.18..
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/README.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/README.md
new file mode 100644
index 0000000..cbe8e09
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/README.md
@@ -0,0 +1,2 @@
+# Network state
+
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_blocknumber.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_blocknumber.md
new file mode 100644
index 0000000..233cab6
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_blocknumber.md
@@ -0,0 +1,70 @@
+# eth\_blockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const latestBlock = await tatum.rpc.blockNumber()
+
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_blockNumber` method returns the number of the most recent block on the Flare blockchain. This method is commonly used to track the current state of the network, monitor for new blocks, or fetch historical data.
+
+Use cases for `eth_blockNumber` include:
+
+* Synchronising a local copy of the blockchain with the network
+* Checking the status of a transaction by comparing its block number to the current block number
+* Determining the current network state for smart contract interactions\
+
+
+### Parameters
+
+The `eth_blockNumber` method does not require any parameters.
+
+### Return Object
+
+The `eth_blockNumber` method returns a single field:
+
+* **`blockNumber`**: The number of the most recent block on the Flare blockchain. The value is returned as a hexadecimal string.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_blockNumber",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4b7" // 1207
+}
+```
+
+In this example, the most recent block number is 1207 (`0x4b7` in hexadecimal notation).
+
+Please note that while this document provides a comprehensive description of the `eth_blockNumber` Flare RPC method, other methods may be needed to obtain full transaction details or perform more complex tasks. Refer to the [Ethereum JSON-RPC documentation](https://eth.wiki/json-rpc/API) for more information.
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getbalance.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getbalance.md
new file mode 100644
index 0000000..1110afa
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getbalance.md
@@ -0,0 +1,108 @@
+# eth\_getBalance
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const balance = await tatum.rpc.getBalance('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+// dotnet add ${your_project} package Tatum
+
+var tatumSdk = await TatumSdk.InitAsync();
+
+var rpcCall = new JsonRpcCall
+{
+ Id = "1",
+ JsonRpc = "2.0",
+ Method = "eth_getBalance",
+ Params = new object[]
+ {
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ }
+};
+
+var result = await tatumSdk.Rpc.Flare.Call(rpcCall);
+```
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBalance` method is an Flare JSON-RPC method that allows you to retrieve the Flare balance of a specified address. This method can be used to query the balance of any Flare address, whether it is a contract or an externally owned account (EOA). A common use case for this method is to display the current balance of a user's account in a wallet application or a decentralized application (DApp).
+
+### Parameters
+
+The method requires two parameters:
+
+1. **`address`** (required): The Flare address of the account or contract whose balance you want to query.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`blockParameter`** (optional): The block number or block identifier to specify the point in time for which you want to query the balance.
+ * Example: `"latest"` or `"0x1"`
+
+#### Transaction Details
+
+For the purpose of this documentation, we'll also describe the `transactions` field of a full transaction object. The `eth_getBalance` method does not return transaction details, but we provide this information for completeness.
+
+A full transaction object includes the following fields:
+
+* **`hash`**: The transaction hash.
+* **`nonce`**: The number of transactions made by the sender prior to this one.
+* **`blockHash`**: The hash of the block in which the transaction was included.
+* **`blockNumber`**: The block number in which the transaction was included.
+* **`transactionIndex`**: The index of the transaction in the block.
+* **`from`**: The sender's address.
+* **`to`**: The recipient's address (or `null` for contract creation transactions).
+* **`value`**: The value transferred, in wei.
+* **`gasPrice`**: The gas price provided by the sender, in wei.
+* **`gas`**: The maximum gas allowed for the transaction.
+* **`input`**: The data sent with the transaction (typically for contract interaction).
+* **`v`**, **`r`**, **`s`**: The raw signature values of the transaction.
+
+### Return Object
+
+The method returns a single field:
+
+* `result`: The Flare balance of the specified address in wei, as a hexadecimal string.
+ * Example: `"0x1a2e1a"`, which corresponds to `1,726,666` wei.
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBalance",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1a2e1a"
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblockbyhash.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblockbyhash.md
new file mode 100644
index 0000000..dd3ba25
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblockbyhash.md
@@ -0,0 +1,137 @@
+# eth\_getBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const block = await tatum.rpc.getBlockByHash('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByHash` is an Flare JSON-RPC method that allows developers to query a specific block in the Flare blockchain by its block hash. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+### Parameters
+
+The `eth_getBlockByHash` method accepts two parameters:
+
+1. **`blockHash`**: The hash of the block you want to retrieve information about.
+ * Type: `String`
+ * Example: `"0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b"`
+2. **`fullTransactionDetails`**: A boolean value indicating whether to return full transaction details or just transaction hashes.
+ * Type: `Boolean`
+ * Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByHash",
+ "params": ["0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b", true],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblockbynumber.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblockbynumber.md
new file mode 100644
index 0000000..2569b13
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblockbynumber.md
@@ -0,0 +1,138 @@
+# eth\_getBlockByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const block = await tatum.rpc.getBlockByNumber('latest', true)
+
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByNumber` is an Flare JSON-RPC method that allows developers to query a specific block in the Flare blockchain by its block number. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+### Parameters
+
+There are two required parameters for this method:
+
+1. **`blockNumber`** - The block number of the block to be retrieved. This can be a hexadecimal string or one of the predefined aliases: `"earliest"`, `"latest"`, or `"pending"`.
+
+ Example: `"0x1b4"`
+2. **`returnFullTransactionObjects`** - A boolean value that determines whether the returned block contains complete transaction objects (`true`) or only transaction hashes (`false`).
+
+ Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByNumber",
+ "params": ["latest", true]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
new file mode 100644
index 0000000..e60dfb8
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
@@ -0,0 +1,68 @@
+# eth\_getBlockTransactionCountByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const response = await tatum.rpc.getBlockTransactionCountByHash('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockTransactionCountByHash` is an Flare RPC method used to fetch the number of transactions in a block by the block's hash. It is useful when you want to know the total number of transactions included in a specific block and don't want to retrieve the entire block data. This method can be used in various scenarios, such as monitoring the network activity or estimating transaction confirmation times.
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`blockHash`**: The hash of the target block for which the transaction count will be retrieved. It should be a valid 32-byte hex string.
+
+Example of the parameter:
+
+* `blockHash`: `"0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"`
+
+### Return
+
+The method returns a single value:
+
+* `transactionCount`: The total number of transactions included in the specified block. It is returned as a hexadecimal value.
+
+### Examples
+
+#### JSON-RPC request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockTransactionCountByHash",
+ "params": [
+ "0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"
+ ]
+}
+```
+
+#### JSON-RPC response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0xa"
+}
+```
+
+In this example, the block with the hash `"0xb903239f8543d04b5dc1ba6579132b143087c68db1b2168786408fcbce568238"` has a total of 10 transactions (indicated by the hexadecimal value `"0xa"`).
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
new file mode 100644
index 0000000..add67b0
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
@@ -0,0 +1,63 @@
+# eth\_getBlockTransactionCountByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const response = await tatum.rpc.getBlockTransactionCountByNumber('0xAD7C5E')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBlockTransactionCountByNumber` Flare JSON-RPC method allows you to retrieve the number of transactions in a specified block. This method is particularly useful when you need to analyze the transaction activity of a specific block. You can use it to gain insights into network usage, analyze the impact of specific events on the Flare network, or monitor transaction congestion in certain blocks.
+
+### Parameters
+
+1. **`blockNumber`**: The block number for which the transaction count should be retrieved. It should be a hex-encoded value representing the block number.
+ * Example: `"0x1b4"` (block number 436)
+
+### Return Object
+
+The return object is a hex-encoded value representing the number of transactions in the specified block.
+
+* Example: `"0xa"` (10 transactions)
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBlockTransactionCountByNumber",
+ "params": ["0x1b4"]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0xa"
+}
+```
+
+
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getcode.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getcode.md
new file mode 100644
index 0000000..5e8352e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getcode.md
@@ -0,0 +1,76 @@
+# eth\_getCode
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const code = await tatum.rpc.getCode('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getCode` method is part of the Flare JSON-RPC API, which allows users to interact with the Flare blockchain. This method is specifically used to retrieve the contract code (bytecode) of an account at a specific block number. It is helpful when developers need to examine the bytecode of a deployed contract or validate that the contract code on the blockchain matches the intended code.
+
+Use cases for this method could include:
+
+* Debugging a smart contract
+* Verifying the integrity of a deployed contract
+* Analyzing contract bytecode for security vulnerabilities
+
+### Parameters
+
+The `eth_getCode` method accepts two parameters:
+
+1. **`address`** (string): The address of the contract whose bytecode you want to retrieve. This should be a 20-byte Flare address, formatted as a hex string with a `0x` prefix.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`block`** (string): The block number at which you want to retrieve the contract code. This can be specified as a hex string or one of the following special keywords:
+ * `"earliest"`: The first block in the blockchain
+ * `"latest"`: The most recent block in the blockchain
+ * `"pending"`: The upcoming block that is being mined
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The `eth_getCode` method returns a string representing the contract bytecode. The returned value is a hex string with a `0x` prefix.
+
+* If the account has contract code, the returned string will contain the bytecode.
+* If the account is not a contract or does not exist, the returned string will be `0x`.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getCode",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x606060...code_here...3839"
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getlogs.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getlogs.md
new file mode 100644
index 0000000..2c54bd1
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getlogs.md
@@ -0,0 +1,111 @@
+# eth\_getLogs
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const logs = await tatum.rpc.getLogs({ address : '0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getLogs` method is an Flare JSON-RPC method that allows developers to query logs generated by the Flare network, specifically event logs emitted by smart contracts. These logs are an essential part of the Flare ecosystem as they provide a way for developers to monitor contract events and track contract state changes.
+
+This method is particularly useful when building decentralized applications (dApps) that rely on events emitted by smart contracts, as it enables developers to retrieve logs based on specific filter criteria. By using `eth_getLogs`, developers can efficiently track and react to events happening on the Flare blockchain.
+
+### Parameters
+
+The `eth_getLogs` method takes a single input parameter: an object containing the filter criteria. The filter object can have the following fields:
+
+* **`fromBlock`**: (optional) The starting block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"fromBlock": "0x1"`
+* **`toBlock`**: (optional) The ending block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"toBlock": "0x2"`
+* **`address`**: (optional) The address or list of addresses of the contracts to filter logs from. Can be a single address or an array of addresses.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`topics`**: (optional) An array of up to four 32-byte topics. Topics are order-dependent, and each topic can be an array of topic hashes or `null`.
+ * Example: `"topics": ["0x123..."]`
+* **`blockhash`**: (optional) The block hash to filter logs from. If provided, `fromBlock` and `toBlock` are ignored.
+ * Example: `"blockhash": "0xc6ef9..."`
+
+In addition to the above fields, the `transactions` field in the filter object can be specified to include full transaction details instead of just transaction hashes. This is useful when you need more information about the transactions in which the events were emitted.
+
+### Return Object
+
+The `eth_getLogs` method returns an array of log objects. Each log object contains the following fields:
+
+* **`removed`**: A boolean indicating whether the log was removed due to a chain reorganization.
+ * Example: `"removed": false`
+* **`logIndex`**: The log index position in the block.
+ * Example: `"logIndex": "0x1"`
+* **`transactionIndex`**: The transaction index position in the block.
+ * Example: `"transactionIndex": "0x0"`
+* **`transactionHash`**: The hash of the transaction that emitted the log.
+ * Example: `"transactionHash": "0x88eef..."`
+* **`blockHash`**: The hash of the block containing the log.
+ * Example: `"blockHash": "0xc6ef9..."`
+* **`blockNumber`**: The block number containing the log.
+ * Example: `"blockNumber": "0x1"`
+* **`address`**: The address of the contract that emitted the log.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`data`**: The data associated with the log.
+ * Example: `"data":"0x0000000000000000000000000000000000000000000000000000000000000020"`
+* **`topics`**: An array of topics (order-dependent) associated with the log.
+ * Example: `"topics": ["0x123..."]`
+
+## JSON-RPC Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getLogs",
+ "params": [
+ {
+ "fromBlock": "0x1",
+ "toBlock": "0x2",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "removed": false,
+ "logIndex": "0x1",
+ "transactionIndex": "0x0",
+ "transactionHash": "0x88eef...",
+ "blockHash": "0xc6ef9...",
+ "blockNumber": "0x1",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "data": "0x0000000000000000000000000000000000000000000000000000000000000020",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+This documentation provides a comprehensive overview of the `eth_getLogs` Flare JSON-RPC method, its parameters, return objects, and JSON-RPC examples. By using this method, developers can effectively query logs generated by the Flare network and use the retrieved data to track and react to events happening on the Flare blockchain.
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getproof.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getproof.md
new file mode 100644
index 0000000..aa6b49c
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getproof.md
@@ -0,0 +1,107 @@
+# eth\_getProof
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.getProof("0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+ "latest")
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getProof` is an Flare JSON-RPC method that retrieves the Merkle-Patricia proof for an account, storage key-value pairs, and account transaction count. It allows developers to verify the state of an account or storage value at a specific block without needing the entire Flare state trie. This method is particularly useful for light clients or off-chain applications that require proof of an account's state or specific storage values.
+
+### Parameters
+
+1. **`address`** - `Data`, 20 Bytes
+ * The address of the account.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`keys`** - `Array` of `Data`
+ * An array of storage keys for which the proof should be generated.
+ * Example: `["0x0000000000000000000000000000000000000000000000000000000000000000"]`
+3. **`blockNumber`** - `Quantity` or `String`
+ * The block number for which the proof should be generated.
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+1. **`accountProof`** - `Array` of `Data`
+ * The serialized Merkle-Patricia proof for the account.
+2. **`balance`** - `Quantity`
+ * The balance of the account at the specified block.
+3. **`codeHash`** - `Data`, 32 Bytes
+ * The hash of the code for the account at the specified block.
+4. **`nonce`** - `Quantity`
+ * The transaction count of the account at the specified block.
+5. **`storageProof`** - `Array` of `Object`
+ * An array of storage proof objects, one for each requested key, containing the following fields:
+ * `key` - `Data`, 32 Bytes: The storage key.
+ * `value` - `Quantity`: The storage value.
+ * `proof` - `Array` of `Data`: The serialized Merkle-Patricia proof for the key-value pair.
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getProof",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ [
+ "0x0000000000000000000000000000000000000000000000000000000000000000"
+ ],
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": {
+ "accountProof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ],
+ "balance": "0xde0b6b3a7640000",
+ "codeHash": "0x...",
+ "nonce": "0x1",
+ "storageProof": [
+ {
+ "key": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "value": "0xde0b6b3a7640000",
+ "proof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ]
+ }
+ ]
+ }
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getstorageat.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getstorageat.md
new file mode 100644
index 0000000..a6a9e69
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getstorageat.md
@@ -0,0 +1,69 @@
+# eth\_getStorageAt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const response = await tatum.rpc.getStorageAt('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', '0x0')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getStorageAt` is an Flare JSON-RPC method that allows you to query the storage value of a contract at a given position. It can be used to inspect the internal state of a smart contract. This method is particularly useful for developers, auditors, and analysts who want to examine contract storage values for various purposes, such as debugging, verifying contract behavior, or analyzing data.
+
+### Parameters
+
+`eth_getStorageAt` accepts three parameters:
+
+1. **`address`**: The address of the contract you want to query.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`position`**: The storage position (slot) you want to query.
+ * Example: `"0x0"`
+3. **`blockParameter`**: The block number, block hash, or one of the string literals (`"earliest"`, `"latest"` or `"pending"`), representing the point in the blockchain to query the storage value.
+ * Example: `"latest"`
+
+### Return Object
+
+The return object is a single string value, representing the storage value at the given position in the contract.
+
+* `result`: The storage value in a 32-byte (64 character) hexadecimal format.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getStorageAt",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "0x0",
+ "latest"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x0000000000000000000000000000000000000000000000000000000000000123"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
new file mode 100644
index 0000000..488f841
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionbyblockhashandindex.md
@@ -0,0 +1,102 @@
+# eth\_getTransactionByBlockHashAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const tx = await tatum.rpc.getTransactionByBlockHashAndIndex('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d', 0)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an Flare JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockHash` (required): The hash of the block containing the transaction.
+ * Example: `"0x9a9a2a0d69b4ff48f7a2a8a26d135e1dbcbd3c3be3e8a3c90de0bcb104e4c4b4"`
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a hexadecimal value.
+ * Example: `"0x0"`
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockHashAndIndex",
+ "params": [
+ "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "0x0"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "from": "0x37a53636ee68f59d9346aabcfc0d36011d9d5b35",
+ "gas": "0x5b8d80",
+ "gasPrice": "0x59682f0a",
+ "maxFeePerGas": "0x59682f10",
+ "maxPriorityFeePerGas": "0x59682f00",
+ "hash": "0x40a0f78e346d15b05efa1861149e5999ea48197dcf104d69160d45b08b7a5118",
+ "input": "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",
+ "nonce": "0xec0",
+ "to": "0x8febc74c26129c8d7e60288c6dccc75eb494aa3c",
+ "transactionIndex": "0x0",
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0xccf7b8fd2d63782e651f4d9650c0ed1a430060fd947d97b6504876f8ea16b357",
+ "s": "0x50c56d90105b1b8aa475c9500137e9b7c4f0a331fee076bc395a695dc471dc05"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
new file mode 100644
index 0000000..9d97282
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionbyblocknumberandindex.md
@@ -0,0 +1,102 @@
+# eth\_getTransactionByBlockNumberAndIndex
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const tx = await tatum.rpc.getTransactionByBlockNumberAndIndex('0xAD7C5E', 0)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByBlockHashAndIndex` is an Flare JSON-RPC method that allows you to fetch the transaction details based on the block hash and the index of the transaction within that block. This method can be useful when you want to retrieve transaction details for a specific transaction without knowing its transaction hash.
+
+Use cases for this method may include:
+
+* Inspecting transaction details for debugging purposes
+* Gathering data for transaction analysis
+* Fetching transaction information for specific blocks in a block explorer application
+
+### Parameters
+
+The `eth_getTransactionByBlockHashAndIndex` method accepts two parameters:
+
+1. `blockNumber` (required): The hash of the block containing the transaction.
+ * Example: `"0x316624"`
+2. `transactionIndex` (required): The index of the transaction within the specified block. The index is a hexadecimal value.
+ * Example: `"0x0"`
+
+### Return Object
+
+The method returns a JSON object containing the following fields:
+
+1. `hash`: The transaction hash as a 32-byte hex string.
+2. `nonce`: The number of transactions made by the sender prior to this one.
+3. `blockHash`: The hash of the block in which this transaction is included.
+4. `blockNumber`: The block number in which this transaction is included.
+5. `transactionIndex`: The index of the transaction within the block.
+6. `from`: The address of the sender.
+7. `to`: The address of the recipient. `null` if the transaction is a contract creation transaction.
+8. `value`: The value transferred in wei.
+9. `gasPrice`: The gas price provided by the sender in wei.
+10. `gas`: The gas limit provided by the sender.
+11. `input`: The data sent along with the transaction.
+
+### JSON Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionByBlockNumberAndIndex",
+ "params": [
+ "0x316624",
+ "0x0"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "from": "0x37a53636ee68f59d9346aabcfc0d36011d9d5b35",
+ "gas": "0x5b8d80",
+ "gasPrice": "0x59682f0a",
+ "maxFeePerGas": "0x59682f10",
+ "maxPriorityFeePerGas": "0x59682f00",
+ "hash": "0x40a0f78e346d15b05efa1861149e5999ea48197dcf104d69160d45b08b7a5118",
+ "input": "0xb1dc65a4000129d4314ec8c4bafb6468cc9d3c21de025fa54002558c9f76aec833406ab600000000000000000000000000000000000000000000000000000000001ccc01f18333a24416e0a0be9cdb78505c9c3c27fa42bccdbe6456cd6c1fc81bee7c0e00000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000022000000000000000000000000000000000000000000000000000000000000003a001000000010100010100010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000003d150000000000000000000000000000000000000000000000000000000000003d17325325668a08b50a9587fd4605ce02dbc5ccefc4883a41b485ff4dc4a4f86f1e0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000a8690000000000000000000000000000000000000000000000000000009d29229e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ba6547e7b549a1f180c5ad4f2e2e7104fecb8373482f3de6574ecbeefdc9be9dfd9f1934768a23584f1508adad8a7bbfbe445a27bed9f1d4538d4e4c9e458b0c5274b6f714f5aee9a8d56aeb8957b6da6b8914e445a46dcd349737b2eb7d72132e41926d07355de577b13e6ec8e55eaaf628b333197a8d1292bed1c375e891e1da1d519aabbebcc6d299b575b7bef506e2db9493de6f0cfdb0436a81597eb155edc63a8ea655a9b405a0c41c923b1734d78b5d9812f36a602ace3d8c5b22beb9519e406f32de9768e518f2b253a95364a9a2838ba5023c52d503fe8fa811c8803399679a19513671b13d4040e46be74e152d39be4f68bfecaa57d27965ba724a09464734faf7230b19e04f4aa581f10066884e2f402af36f0cdbf08de95e190f4f31fd3b718c1317b65fba9e7ea45ef6180e4861839c6395c814214ee8d56b28ba19f47b6b80f43045635432971b30f2bfb3a26a53ca502bf21fa598c5ddb934b000000000000000000000000000000000000000000000000000000000000000b3ab737e679aefe131ad3efc850fd2c50b316aabcdaa4368587d9606df84b3590541698c7c5538111187964e1b3f39fa033033bb7cab30275ea11b912089663ec43243ff37fa9d2cce04dfce25738c3a484d42f8d8a2c6be226627606f75788ee0e777481b5bd100d00d118bddd18e8726f7a54333b6228f57fa3237799079eb56e6e0ac0cb0f334d23f7284e2dcb2f463d8104fc198389e42a9d1bad1dcfe983115d3d85474db611a6e82b2f61b8d93efa77bc039bd5b3b0f02a7fc587d4a12a0daf256c21ecb9664e6c90c2bfb72a753ff008d3306f7cd4c823df6685fc4cba1514ed132d6367a8f99fba241fc6ef6917f5279ebfdd3e05a296e5c4d77a5463037d7c8180d0644d7e90123918c30fca011d710201ceabcae277924f32ff6b9d0e4d285eb59b4b56d3af8d4b2ab1a39ec2d4324e49deea661cbd43f21cbdc76a10a14055ecdd3251a5860c3bb02bcc1f21da5564fc05adbac70c7565fb5f44b8",
+ "nonce": "0xec0",
+ "to": "0x8febc74c26129c8d7e60288c6dccc75eb494aa3c",
+ "transactionIndex": "0x0",
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0xccf7b8fd2d63782e651f4d9650c0ed1a430060fd947d97b6504876f8ea16b357",
+ "s": "0x50c56d90105b1b8aa475c9500137e9b7c4f0a331fee076bc395a695dc471dc05"
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionbyhash.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionbyhash.md
new file mode 100644
index 0000000..7f4d0b5
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionbyhash.md
@@ -0,0 +1,92 @@
+# eth\_getTransactionByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const tx = await tatum.rpc.getTransactionByHash('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionByHash` is an Flare JSON-RPC method that allows you to query transaction details based on its hash. This method is useful when you want to retrieve information about a specific transaction, such as its sender, receiver, value, and more. Common use cases include tracking transaction status, monitoring incoming transactions, or analyzing historical transaction data.
+
+### Parameters
+
+The `eth_getTransactionByHash` method takes one parameter:
+
+* **`transactionHash`**: The hash of the transaction you want to retrieve. This should be a 32-byte hash string with a `0x` prefix.
+ * Example: `"0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"`
+
+### Return Object
+
+The method returns a transaction object with the following fields:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getTransactionByHash",
+ "params": ["0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"],
+ "id": 1
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "from": "0x53e8577c4347c365e4e0da5b57a589cb6f2ab848",
+ "gas": "0x3c524",
+ "gasPrice": "0x306dc421e",
+ "hash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "input": "0x50bb4e7f00000000000000000000000074b4551c177592a908c6ab9ce671bfe8c1b5bd40000000000000000000000000000000000000000000000000000056b990e70e000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000006068747470733a2f2f6574682d6d61696e6e65742e672e616c6368656d792e636f6d2f76322f72646f704c505054424a31536f786b2d555179306b7464676f4b45326146637a2f6765744e4654732f3f6f776e65723d766974616c696b2e657468",
+ "nonce": "0xc97",
+ "to": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "transactionIndex": "0x4",
+ "value": "0x0",
+ "type": "0x0",
+ "chainId": "0xaa36a7",
+ "v": "0x1546d71",
+ "r": "0xf89098451217613aa4abbb3f8988e75e20ae948d07bf8b26c472bc9bda50c9d9",
+ "s": "0x15cfb5b34bcb23730aeadc28df3b66fa9cf28103ffc8b557d76f0c1df078028e"
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactioncount.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactioncount.md
new file mode 100644
index 0000000..4ae4568
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactioncount.md
@@ -0,0 +1,74 @@
+# eth\_getTransactionCount
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.getTransactionCount('0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86', 'pending')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getTransactionCount` method is an Flare JSON-RPC method that retrieves the number of transactions sent from a given address. It is a useful method for developers who need to keep track of an account's nonce value to avoid transaction collisions or incorrect order of execution. The nonce value is essential for ensuring transaction uniqueness and preventing replay attacks.
+
+Use cases for this method include:
+
+* Determining the nonce value for a new transaction to be sent from a specific address
+* Monitoring the number of transactions sent by an address to observe its activity
+* Troubleshooting transaction issues and verifying if a transaction was submitted successfully
+
+### Parameters
+
+The `eth_getTransactionCount` method accepts two parameters:
+
+1. **`address`** - The Flare address whose transaction count will be retrieved.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`blockParameter`** - A string indicating the block number or block state to consider when retrieving the transaction count.
+ * Possible values: `"earliest"`, `"latest"`, `"pending"`, or a specific block number in hexadecimal format
+ * Example: `"latest"`
+
+### Return Object
+
+The method returns a single value:
+
+* **`transactionCount`** - A hexadecimal representation of the number of transactions sent from the specified address.
+ * Example: `"0x1e"`
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionCount",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1e"
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionreceipt.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionreceipt.md
new file mode 100644
index 0000000..0c8ec15
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_gettransactionreceipt.md
@@ -0,0 +1,129 @@
+# eth\_getTransactionReceipt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const tx = await tatum.rpc.getTransactionReceipt('0x6aefbd1a9c9e4c310cadde3bcdd809a14da87caa8fa4f10ca04d9e357a3907e9')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+// dotnet add ${your_project} package Tatum
+
+var tatumSdk = await TatumSdk.InitAsync();
+
+var rpcCall = new JsonRpcCall
+{
+ Id = "1",
+ JsonRpc = "2.0",
+ Method = "eth_getTransactionReceipt",
+ Params = new object[]
+ {
+ "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"
+ }
+};
+
+var result = await tatumSdk.Rpc.Flare.Call(rpcCall);
+```
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getTransactionReceipt` is an Flare JSON-RPC method that retrieves the transaction receipt of a given transaction hash. This method is particularly useful when you need to obtain detailed information about a transaction's execution, such as its status (success or failure), gas usage, and logs (events). Common use cases include checking the status of a transaction after it has been mined or inspecting the events emitted by a smart contract during a specific transaction.
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`transactionHash`**: The hash of the transaction for which you want to obtain the receipt.
+ * Example: `"0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+* **`transactionHash`**: The hash of the transaction.
+* **`transactionIndex`**: The transaction's index position in the block.
+* **`blockHash`**: The hash of the block where this transaction was mined.
+* **`blockNumber`**: The block number where this transaction was mined.
+* **`from`**: The address of the sender.
+* **`to`**: The address of the receiver. `null` when it's a contract creation transaction.
+* **`cumulativeGasUsed`**: The total amount of gas used when this transaction was executed in the block.
+* **`gasUsed`**: The amount of gas used by this specific transaction alone.
+* **`contractAddress`**: The address of the contract created, if the transaction was a contract creation. Otherwise, `null`.
+* **`logs`**: An array of log objects, which were emitted during the transaction.
+* **`logsBloom`**: A 256-byte bloom filter, which is a compressed representation of the logs emitted during the transaction.
+* **`status`**: The status of the transaction's execution. `"0x1"` indicates success, while `"0x0"` indicates failure.
+
+### JSON-RPC Examples
+
+Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getTransactionReceipt",
+ "params": [
+ "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13"
+ ]
+}
+```
+
+Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "blockNumber": "0x316624",
+ "contractAddress": null,
+ "cumulativeGasUsed": "0x7ad81",
+ "effectiveGasPrice": "0x306dc421e",
+ "from": "0x53e8577c4347c365e4e0da5b57a589cb6f2ab848",
+ "gasUsed": "0x3c518",
+ "logs": [
+ {
+ "address": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "topics": [
+ "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "0x00000000000000000000000074b4551c177592a908c6ab9ce671bfe8c1b5bd40",
+ "0x000000000000000000000000000000000000000000000000000056b990e70e00"
+ ],
+ "data": "0x",
+ "blockNumber": "0x316624",
+ "transactionHash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "transactionIndex": "0x4",
+ "blockHash": "0x1091a5831b3556e80e53598c24e9d592e104dba0428f47f94c61523eb52d09d8",
+ "logIndex": "0x3",
+ "removed": false
+ }
+ ],
+ "logsBloom": "0x00000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000020000010000000000000800000000000000000000000010000040000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000100000000000000000000000000000000002000000200000000000100000000000800000000000000000000020000000000000000000000200000000000000000000000000000000000000000000",
+ "status": "0x1",
+ "to": "0x211500d1960bdb7ba3390347ffd8ad486b897a18",
+ "transactionHash": "0xa536596d043c03d709aaccbc53f421963fe3537274e86444cd984404cf9ecb13",
+ "transactionIndex": "0x4",
+ "type": "0x0"
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getunclecountbyblockhash.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
new file mode 100644
index 0000000..7154c88
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getunclecountbyblockhash.md
@@ -0,0 +1,70 @@
+# eth\_getUncleCountByBlockHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.getUncleCountByBlockHash('0x48dfcf43404dffdb3b93a0b0d9982b642b221187bc3ed5c023bdab6c0e863e3d')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an Flare JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the Flare network and to analyze the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralization of the Flare network. The inclusion of uncles helps prevent centralization and ensures the mining process remains competitive.
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockHash`: The hash of the block for which you want to get the uncle count.
+ * Example value: `"0x3a3e528dcd6e05a614c9241b0a9296db961fa6a92e05af9f6c0d7d2f6bc92f7a"`
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockHash` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockHash",
+ "params": [
+ "0x3a3e528dcd6e05a614c9241b0a9296db961fa6a92e05af9f6c0d7d2f6bc92f7a"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x1"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
new file mode 100644
index 0000000..fff7e2e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/network-state/eth_getunclecountbyblocknumber.md
@@ -0,0 +1,71 @@
+# eth\_getUncleCountByBlockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const result = await tatum.rpc.getUncleCountByBlockNumber('0xAD7C5E')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getUncleCountByBlockHash` method is an Flare JSON-RPC method that returns the number of uncles in a specified block by its hash. This method can be useful for gathering information about the performance of the Flare network and to analyze the security of the blockchain.
+
+Uncles are blocks that are not included in the main blockchain but are still valid, and they contribute to the overall security and decentralization of the Flare network. The inclusion of uncles helps prevent centralization and ensures the mining process remains competitive.
+
+### Parameters
+
+The `eth_getUncleCountByBlockHash` method takes one parameter:
+
+* `blockNumber`: The number of the block for which you want to get the uncle count.
+ * Example value: `"0x12345"`
+
+### Return Object
+
+The return object for this method is a hex-encoded integer representing the number of uncles in the specified block.
+
+* Example value: `"0x1"` (1 uncle)
+
+### JSON-RPC Request and Response Examples
+
+Here is an example JSON-RPC request and response for the `eth_getUncleCountByBlockNumber` method:
+
+**Request:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getUncleCountByBlockNumber",
+ "params": [
+ "0x12345"
+ ]
+}
+```
+
+**Response:**
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x1"
+}
+```
+
+In this example, the JSON-RPC request asks for the number of uncles in the block with the specified hash. The response indicates that there is one uncle in the block.
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/README.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/README.md
new file mode 100644
index 0000000..1b1ccbc
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/README.md
@@ -0,0 +1,2 @@
+# Transaction
+
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_estimategas.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_estimategas.md
new file mode 100644
index 0000000..869929a
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_estimategas.md
@@ -0,0 +1,92 @@
+# eth\_estimateGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const estimate = await tatum.rpc.estimateGas({
+ "from": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e86",
+ "to": "0xa41d19F4258a388c639B7CcD938FCE3fb7D05e87",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060"
+ })
+
+ tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_estimateGas` is an Flare JSON-RPC method that estimates the amount of gas required to execute a given transaction. This method can be used to determine the gas cost before sending a transaction, allowing developers to better predict the gas fees and avoid issues like out-of-gas errors.
+
+Use cases for `eth_estimateGas` include:
+
+* Estimating gas costs for contract deployments
+* Estimating gas costs for contract function calls
+* Estimating gas costs for standard Flare transfers
+
+### Parameters
+
+The `eth_estimateGas` method takes a single parameter, an object representing the transaction details. The fields in the transaction object include:
+
+* **`from`** (optional, string): The address that the transaction is sent from.
+ * Example: `"from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`to`** (optional, string): The address the transaction is sent to.
+ * Example: `"to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`gas`** (optional, string): The maximum amount of gas provided for the transaction.
+ * Example: `"gas": "0x76c0"`
+* **`gasPrice`** (optional, string): The price of gas in wei.
+ * Example: `"gasPrice": "0x9184e72a000"`
+* **`value`** (optional, string): The amount of Flare to send in the transaction, in wei.
+ * Example: `"value": "0xde0b6b3a7640000"`
+* **`data`** (optional, string): The data payload of the transaction, typically used for contract function calls or contract deployment.
+ * Example: `"data": "0x606060..."`
+* **`nonce`** (optional, string): The transaction count of the `from` address.
+ * Example: `"nonce": "0x1"`
+
+### Return Object
+
+The return value of the `eth_estimateGas` method is a single field:
+
+* `gasEstimate` (string): The estimated gas cost for the transaction, represented as a hexadecimal string.
+ * Example: `"0x5208"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_estimateGas",
+ "params": [
+ {
+ "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "to": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "value": "0xde0b6b3a7640000",
+ "data": "0x606060..."
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x5208"
+}
+```
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_gasprice.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_gasprice.md
new file mode 100644
index 0000000..ed4d299
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_gasprice.md
@@ -0,0 +1,60 @@
+# eth\_gasPrice
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const gasPrice = await tatum.rpc.gasPrice()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_gasPrice` method is an Flare JSON-RPC method used to estimate the average gas price required for transactions in the Flare network. This method provides a suggestion for the gas price to be used in a transaction to increase the likelihood of it being mined and included in a block in a reasonable amount of time. The `eth_gasPrice` method is particularly useful for developers and users who want to create and send transactions, as it helps them estimate the appropriate gas price to ensure timely processing.
+
+### Parameters
+
+The `eth_gasPrice` method does not require any parameters.
+
+### Return Value
+
+The `eth_gasPrice` method returns a single value as a hexadecimal string:
+
+* `gasPrice`: The estimated average gas price in wei. Example: `"0x4a817c800"`
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_gasPrice",
+ "params": []
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4a817c800"
+}
+```
+
+By using the `eth_gasPrice` method, developers and users can estimate the appropriate gas price for their transactions, improving the overall user experience and ensuring that their transactions are processed in a timely manner.
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_maxpriorityfeepergas.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
new file mode 100644
index 0000000..4e9c28e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_maxpriorityfeepergas.md
@@ -0,0 +1,62 @@
+# eth\_maxPriorityFeePerGas
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const gasPrice = await tatum.rpc.maxPriorityFeePerGas()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_maxPriorityFeePerGas` RPC method is used to retrieve the maximum priority fee per gas set by the user for a transaction. This method can be used to determine the maximum fee that can be paid for a transaction to be included in a block quickly.
+
+### Use case
+
+This method is particularly useful when the user wants to ensure that a transaction is processed quickly, even in a congested network where transaction fees may fluctuate rapidly. By setting a high maximum priority fee per gas, the user can ensure that the transaction is processed as quickly as possible.
+
+### Parameters
+
+`None.`
+
+## Return Object
+
+* `maxPriorityFeePerGas` - The maximum priority fee per gas the user is willing to pay, in wei.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_maxPriorityFeePerGas",
+ "params": [],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x3b9aca00"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_sendrawtransaction.md b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_sendrawtransaction.md
new file mode 100644
index 0000000..e9e2de5
--- /dev/null
+++ b/docs/rpc/evm-blockchains/flare-rpc-documentation/transaction/eth_sendrawtransaction.md
@@ -0,0 +1,62 @@
+# eth\_sendRawTransaction
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Flare, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.FLARE})
+
+const gasPrice = await tatum.rpc.sendRawTransaction('0x0000.......')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_sendRawTransaction` RPC method is used to send a signed and serialized Flare transaction to the network. This method is particularly useful when you want to have full control over the signing process, e.g., when using hardware wallets, cold storage, or custom signing libraries. It can be utilized in various use cases, such as transferring Flare, interacting with smart contracts, or deploying new contracts.
+
+### Parameters
+
+The method accepts a single parameter:
+
+* **`data`**: The signed and serialized transaction data as a hexadecimal string.
+
+### Return Value
+
+The method returns a single value:
+
+* `transactionHash`: The hash of the submitted transaction as a hexadecimal string, e.g., `"0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"`.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_sendRawTransaction",
+ "params": [
+ "0xf86d8201...94a7bc"
+ ]
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/README.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/README.md
new file mode 100644
index 0000000..2175088
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/README.md
@@ -0,0 +1,11 @@
+# Haqq RPC documentation
+
+Haqq represents a scalable Proof-of-Stake blockchain with high throughput, offering seamless compatibility and interoperability with Ethereum. It is constructed utilizing the Cosmos SDK framework, leveraging the underlying Tendermint Core consensus engine.
+
+Haqq provides the capability to operate Ethereum in its original form within a specialized blockchain framework based on Cosmos. This empowers developers to access Ethereum's desired functionalities while concurrently harnessing the advantages of Tendermint's Proof-of-Stake mechanism. Moreover, due to its foundation on the Cosmos SDK, Haqq enables seamless value transfer across the broader Cosmos Ecosystem through the utilization of the Inter Blockchain Communication Protocol (IBC).
+
+Haqq comprehensively integrates with standard web3 JSON-RPC APIs.
+
+JSON-RPC functionality is accessible through various communication channels. Haqq extends its support to JSON-RPC over both HTTP and WebSocket connections. The activation of these communication modes can be achieved either via command-line flags or configuration settings within the app.toml file.
+
+In the Ethereum JSON-RPC ecosystem, a systematic namespace structure is employed. RPC methods are thoughtfully grouped into distinct categories based on their intended functions. Each method name comprises the namespace, an underscore, and the specific method title within the given namespace. For instance, the eth\_call method resides within the eth namespace.
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/README.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/README.md
new file mode 100644
index 0000000..563f334
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/README.md
@@ -0,0 +1,2 @@
+# Mempool
+
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool_content.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool_content.md
new file mode 100644
index 0000000..32d3009
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool_content.md
@@ -0,0 +1,131 @@
+# txpool\_content
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ})
+
+const content = await tatum.rpc.txPoolContent()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_content` method provides information about the transactions currently pending in the transaction pool of the Haqq node. It can be helpful for developers and node operators to monitor and manage the transaction pool, especially in scenarios where it's necessary to analyze transaction congestion or prioritize specific transactions.
+
+Use cases for the `txpool_content` method include:
+
+* Analyzing network congestion by inspecting the transaction pool
+* Prioritizing transactions by gas price
+* Monitoring transactions from specific addresses
+* Debugging and troubleshooting pending transactions
+
+{% embed url="https://codepen.io/tatum-devrel/pen/vYQowQR" %}
+
+### Parameters
+
+This method does not require any parameters.
+
+### Return Object
+
+The `txpool_content` method returns an object with two fields: `pending` and `queued`. Each field contains a nested object with addresses as keys and their respective transactions as values.
+
+* **`pending`**: An object containing transactions that are currently pending for inclusion in the next block(s).
+* **`queued`**: An object containing transactions that are currently queued (i.e., transactions that do not meet certain criteria for inclusion in the next block, like low gas price or nonce gaps).
+
+Each transaction object includes the following information:
+
+* **`hash`**: The hash of the transaction (32 bytes).
+* **`nonce`**: The number of transactions sent by the sender prior to this one (integer).
+* **`blockHash`**: The hash of the block in which the transaction was included (32 bytes), or `null` if the transaction is not yet mined.
+* **`blockNumber`**: The block number in which the transaction was included (integer), or `null` if the transaction is not yet mined.
+* **`transactionIndex`**: The index of the transaction in the block (integer), or `null` if the transaction is not yet mined.
+* **`from`**: The address of the sender (20 bytes).
+* **`to`**: The address of the receiver (20 bytes), or `null` for contract creation transactions.
+* **`value`**: The value transferred in the transaction, in wei.
+* **`gasPrice`**: The price of gas for the transaction, in wei.
+* **`maxFeePerGas`** - The maximum fee per gas set in the transaction.
+* **`maxPriorityFeePerGas`** - The maximum priority gas fee set in the transaction.
+* **`gas`**: The maximum amount of gas the transaction is allowed to consume.
+* **`input`**: The data payload of the transaction (string), or `0x` for simple value transfers.
+
+### JSON-RPC Request Example
+
+```json
+jsonCopy code{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "txpool_content",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x01d3b93aaade8a4066daabc8fd8482173a6ad120",
+ "gas": "0x1c9c380",
+ "gasPrice": "0x16cf917",
+ "maxFeePerGas": "0x16cf917",
+ "maxPriorityFeePerGas": "0x16cf917",
+ "hash": "0x1da9c2a8f0787bac4747c5ed1035e81f6a6745aeea43943e63635fc367b817f7",
+ "input": "0x00000000",
+ "nonce": "0xc5",
+ "to": "0x4f023eb8c6bc3116e35b67e03bf2c17f2e4f7e7e",
+ "transactionIndex": null,
+ "value": "0x0",
+ "type": "0x2",
+ "accessList": [],
+ "chainId": "0xaa36a7",
+ "v": "0x1",
+ "r": "0x14f7578b57fd9f87acf5bbceb0a47f2d2d3f39b49169357457618c9634c45e8a",
+ "s": "0x775fa9976c571751a79f069f8c96f6489f286246e157a31fa99b33062631b46d"
+ }
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": {
+ "blockHash": null,
+ "blockNumber": null,
+ "from": "0x03321406635a04d37cf9211f2ea3afc83a87e777",
+ "gas": "0x5208",
+ "gasPrice": "0xc570bd200",
+ "hash": "0x05f5fb8e46793fafdc924917c0afdd0afb4a53cb562542d5399234bc1eff759b",
+ "input": "0x",
+ "nonce": "0x4dc359",
+ "to": "0x77b1c86ab0aa9066803ed567e1f00973976638f6",
+ "transactionIndex": null,
+ "value": "0xb1a2b96602aa20",
+ "type": "0x0",
+ "chainId": "0xaa36a7",
+ "v": "0x1546d72",
+ "r": "0x62bd220b95ec13827c0d9b643b9beaf6f4c66d4a8ef08bb10f93d5e5c7ae0068",
+ "s": "0x467f76847cfdf43a002defe054030c1a88a9e6f56539c051c3cba46b2dd2cc89"
+ }
+ }
+ }
+ }
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool_inspect.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool_inspect.md
new file mode 100644
index 0000000..37d475f
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool_inspect.md
@@ -0,0 +1,78 @@
+# txpool\_inspect
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ})
+
+const inspect = await tatum.rpc.txPoolInspect()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_inspect` method is a JSON-RPC method used to inspect the current transaction pool of a running Haqq node. The method allows you to view all pending transactions and their details, including transaction hashes, gas prices, and transaction data. This method is useful for developers who want to monitor the status of pending transactions or debug transaction-related issues.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/mdQNYaK" %}
+
+### Parameters
+
+The `txpool_inspect` method takes one optional parameter:
+
+* **`include`**: A string specifying the type of transactions to include in the response. Possible values are **`pending`** (default) and **`queued`**.
+
+### Return Object
+
+The `txpool_inspect` method returns an object with the following fields:
+
+* **`pending`**: An array of transaction objects, with textual data
+* **`queued`**: An array of transaction objects, with textual data
+
+## Example Request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "txpool_inspect",
+ "params": [
+ "pending"
+ ],
+ "id": 1
+}
+```
+
+## Example Response:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": {
+ "0x01d3B93AaADE8A4066DAaBc8fd8482173A6aD120": {
+ "197": "0x4f023eB8C6BC3116E35B67E03bf2C17f2e4f7e7e: 0 wei + 30000000 gas ร 23918871 wei"
+ }
+ },
+ "queued": {
+ "0x03321406635a04D37Cf9211F2ea3AFc83a87e777": {
+ "5096281": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 49999988041886240 wei + 21000 gas ร 53000000000 wei",
+ "8308536": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 100000000000000000 wei + 21000 gas ร 53000000000 wei",
+ "231211221": "0x77b1C86Ab0aa9066803eD567e1F00973976638F6: 1000000000000000 wei + 21000 gas ร 11958113760 wei"
+ }
+ }
+ }
+}
+```
+
+\
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool_status.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool_status.md
new file mode 100644
index 0000000..0dbc83b
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/mempool/txpool_status.md
@@ -0,0 +1,66 @@
+# txpool\_status
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ})
+
+const status = await tatum.rpc.txPoolStatus()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `txpool_status` method returns statistics about the current state of the transaction pool. The transaction pool is a queue of pending transactions waiting to be included in the next block by miners.
+
+This method can be useful for monitoring the health of the Haqq network and analyzing the behavior of the miners. It can also be used to estimate the time it will take for a transaction to be processed, as well as to determine the gas price necessary to ensure prompt inclusion of a transaction in the next block.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/XWyvwOK" %}
+
+### Parameters
+
+This method does not take any parameters.
+
+### Return Object
+
+The `txpool_status` method returns an object with the following fields:
+
+* **`pending`**: Number of pending transactions in the pool
+* **`queued`**: Number of queued transactions in the pool
+
+### Example Request
+
+```json
+{
+ "jsonrpc":"2.0",
+ "method":"txpool_status",
+ "params":[],
+ "id":1
+}
+```
+
+### Example Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "pending": 4,
+ "queued": 10
+ }
+}
+```
+
+In this example response, there are currently 4 pending transactions and 10 queued transactions waiting to be processed by miners.
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/README.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/README.md
new file mode 100644
index 0000000..bd96ae8
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/README.md
@@ -0,0 +1,2 @@
+# Network/Client information
+
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/eth_chainid.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/eth_chainid.md
new file mode 100644
index 0000000..208e889
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/eth_chainid.md
@@ -0,0 +1,66 @@
+# eth\_chainId
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ})
+
+const id = await tatum.rpc.chainId()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_chainId` method is an Haqq JSON-RPC method that allows developers to retrieve the currently configured chain ID of the Haqq network they are connected to. The chain ID is a unique identifier for different Haqq networks, such as Haqq Mainnet or various testnets.
+
+This method is particularly useful when building applications that interact with multiple Haqq networks or need to verify the network to prevent replay attacks. By checking the chain ID, an application can ensure it is interacting with the intended network.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/NWEQVzo" %}
+
+### Parameters
+
+The `eth_chainId` method does not have any input parameters.
+
+### Return Object
+
+The return object contains a single field:
+
+* **`chainId`**: The hexadecimal string representation of the chain ID.
+
+### Example Request and Response
+
+JSON-RPC request:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_chainId",
+ "params": []
+}
+```
+
+JSON-RPC response:
+
+````json
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x2be3"
+}
+```
+````
+
+In this example, the returned chain ID is `0x2be3`, which corresponds to the Haqq Mainnet.
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/web3_clientversion.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/web3_clientversion.md
new file mode 100644
index 0000000..72b2333
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-client-information/web3_clientversion.md
@@ -0,0 +1,65 @@
+# web3\_clientVersion
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ})
+
+const version = await tatum.rpc.clientVersion()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`web3_clientVersion` is a method of the Haqq JSON-RPC API that allows the client to retrieve the current version of the Haqq client software being used by the node.
+
+This method is read-only and does not require authentication. The `web3_clientVersion` method can be used by developers to confirm the version of the Haqq client software they are using and ensure that it is compatible with their application.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/eYQqajp" %}
+
+### Parameters
+
+This method has no parameters. It only retrieves the current version of the Haqq client software.
+
+### Return Object
+
+The `web3_clientVersion` method returns a string representing the version of the Haqq client software being used. The string includes the client name, version number, and build information.
+
+* `String` - Version string of the Haqq client software being used.
+
+### Example Request
+
+#### JSON Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "web3_clientVersion",
+ "params": [],
+ "id": 67
+}
+```
+
+### Example Response
+
+#### JSON Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 67,
+ "result": "Version dev ()\nCompiled at using Go go1.20.6 (amd64)"
+}
+```
+
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/README.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/README.md
new file mode 100644
index 0000000..cbe8e09
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/README.md
@@ -0,0 +1,2 @@
+# Network state
+
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_blocknumber.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_blocknumber.md
new file mode 100644
index 0000000..2f6bcf3
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_blocknumber.md
@@ -0,0 +1,71 @@
+# eth\_blockNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ})
+
+const latestBlock = await tatum.rpc.blockNumber()
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_blockNumber` method returns the number of the most recent block on the Haqq blockchain. This method is commonly used to track the current state of the network, monitor for new blocks, or fetch historical data.
+
+Use cases for `eth_blockNumber` include:
+
+* Synchronising a local copy of the blockchain with the network
+* Checking the status of a transaction by comparing its block number to the current block number
+* Determining the current network state for smart contract interactions\
+
+
+{% embed url="https://codepen.io/Jan-Musil-the-lessful/pen/ZEmwwYX" %}
+
+### Parameters
+
+The `eth_blockNumber` method does not require any parameters.
+
+### Return Object
+
+The `eth_blockNumber` method returns a single field:
+
+* **`blockNumber`**: The number of the most recent block on the Haqq blockchain. The value is returned as a hexadecimal string.
+
+### JSON-RPC Request Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_blockNumber",
+ "params": []
+}
+```
+
+### JSON-RPC Response Example
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x4b7" // 1207
+}
+```
+
+In this example, the most recent block number is 1207 (`0x4b7` in hexadecimal notation).
+
+Please note that while this document provides a comprehensive description of the `eth_blockNumber` Haqq RPC method, other methods may be needed to obtain full transaction details or perform more complex tasks. Refer to the [Ethereum JSON-RPC documentation](https://eth.wiki/json-rpc/API) for more information.
+
+\
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getbalance.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getbalance.md
new file mode 100644
index 0000000..8d6fc09
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getbalance.md
@@ -0,0 +1,110 @@
+# eth\_getBalance
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ}
+
+const balance = await tatum.rpc.getBalance('0x2c5b9a513be2240e948a631baafb53cc0beacfda')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+
+{% tab title="C#" %}
+```csharp
+// dotnet add ${your_project} package Tatum
+
+var tatumSdk = await TatumSdk.InitAsync();
+
+var rpcCall = new JsonRpcCall
+{
+ Id = "1",
+ JsonRpc = "2.0",
+ Method = "eth_getBalance",
+ Params = new object[]
+ {
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ }
+};
+
+var result = await tatumSdk.Rpc.Haqq.Call(rpcCall);
+```
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBalance` method is an Haqq JSON-RPC method that allows you to retrieve the Haqq balance of a specified address. This method can be used to query the balance of any Haqq address, whether it is a contract or an externally owned account (EOA). A common use case for this method is to display the current balance of a user's account in a wallet application or a decentralized application (DApp).
+
+{% embed url="https://codepen.io/Jan-Musil-the-lessful/pen/ZEmwZvp?editors=1111" %}
+
+### Parameters
+
+The method requires two parameters:
+
+1. **`address`** (required): The Haqq address of the account or contract whose balance you want to query.
+ * Example: `"0x2C5B9a513bE2240e948a631bAaFB53cc0bEAcfda"`
+2. **`blockParameter`** (optional): The block number or block identifier to specify the point in time for which you want to query the balance.
+ * Example: `"latest"` or `"0x1"`
+
+#### Transaction Details
+
+For the purpose of this documentation, we'll also describe the `transactions` field of a full transaction object. The `eth_getBalance` method does not return transaction details, but we provide this information for completeness.
+
+A full transaction object includes the following fields:
+
+* **`hash`**: The transaction hash.
+* **`nonce`**: The number of transactions made by the sender prior to this one.
+* **`blockHash`**: The hash of the block in which the transaction was included.
+* **`blockNumber`**: The block number in which the transaction was included.
+* **`transactionIndex`**: The index of the transaction in the block.
+* **`from`**: The sender's address.
+* **`to`**: The recipient's address (or `null` for contract creation transactions).
+* **`value`**: The value transferred, in wei.
+* **`gasPrice`**: The gas price provided by the sender, in wei.
+* **`gas`**: The maximum gas allowed for the transaction.
+* **`input`**: The data sent with the transaction (typically for contract interaction).
+* **`v`**, **`r`**, **`s`**: The raw signature values of the transaction.
+
+### Return Object
+
+The method returns a single field:
+
+* `result`: The Haqq balance of the specified address in wei, as a hexadecimal string.
+ * Example: `"0x1a2e1a"`, which corresponds to `1,726,666` wei.
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBalance",
+ "params": [
+ "0x2C5B9a513bE2240e948a631bAaFB53cc0bEAcfda",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0x1a2e1a"
+}
+```
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblockbyhash.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblockbyhash.md
new file mode 100644
index 0000000..1048f61
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblockbyhash.md
@@ -0,0 +1,139 @@
+# eth\_getBlockByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ})
+
+const block = await tatum.rpc.getBlockByHash('0x300e4057498875ef62a7632c78077d9fa79265e484415d337d1f529ca4660ee6', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByHash` is an Haqq JSON-RPC method that allows developers to query a specific block in the Haqq blockchain by its block hash. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/JjegqOb" %}
+
+### Parameters
+
+The `eth_getBlockByHash` method accepts two parameters:
+
+1. **`blockHash`**: The hash of the block you want to retrieve information about.
+ * Type: `String`
+ * Example: `"0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b"`
+2. **`fullTransactionDetails`**: A boolean value indicating whether to return full transaction details or just transaction hashes.
+ * Type: `Boolean`
+ * Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByHash",
+ "params": ["0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b", true],
+ "id": 1
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblockbynumber.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblockbynumber.md
new file mode 100644
index 0000000..e3fd15b
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblockbynumber.md
@@ -0,0 +1,139 @@
+# eth\_getBlockByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ})
+
+const block = await tatum.rpc.getBlockByNumber('latest', true)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockByNumber` is an Haqq JSON-RPC method that allows developers to query a specific block in the Haqq blockchain by its block number. This method can be used in various scenarios, such as analyzing historical transactions, validating the state of the blockchain, or monitoring the progress of mining activities.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/KKrOLvY" %}
+
+### Parameters
+
+There are two required parameters for this method:
+
+1. **`blockNumber`** - The block number of the block to be retrieved. This can be a hexadecimal string or one of the predefined aliases: `"earliest"`, `"latest"`, or `"pending"`.
+
+ Example: `"0x1b4"`
+2. **`returnFullTransactionObjects`** - A boolean value that determines whether the returned block contains complete transaction objects (`true`) or only transaction hashes (`false`).
+
+ Example: `true`
+
+### Return Object
+
+The returned block object includes the following fields:
+
+* **`number`** - The block number (hexadecimal string).
+* **`hash`** - The block hash (32-byte string).
+* **`parentHash`** - The hash of the parent block (32-byte string).
+* **`nonce`** - The nonce used to generate the block (8-byte string).
+* **`sha3Uncles`** - The SHA3 hash of the uncles in the block (32-byte string).
+* **`logsBloom`** - The logs bloom filter of the block (256-byte string).
+* **`transactionsRoot`** - The root of the transaction trie (32-byte string).
+* **`stateRoot`** - The root of the state trie (32-byte string).
+* **`miner`** - The address of the miner who mined the block (20-byte string).
+* **`difficulty`** - The difficulty of the block (hexadecimal string).
+* **`totalDifficulty`** - The total difficulty of the chain up to this block (hexadecimal string).
+* **`extraData`** - Extra data included by the miner in the block (byte string).
+* **`size`** - The block size in bytes (hexadecimal string).
+* **`gasLimit`** - The gas limit for the block (hexadecimal string).
+* **`gasUsed`** - The total gas used by all transactions in the block (hexadecimal string).
+* **`timestamp`** - The block timestamp (hexadecimal string).
+* **`transactions`** - An array of transaction objects or transaction hashes, depending on the `returnFullTransactionObjects` parameter.
+* **`uncles`** - An array of uncle block hashes (32-byte strings).
+
+If `returnFullTransactionObjects` is `true`, the `transactions` field contains transaction objects with the following fields:
+
+* **`hash`** - The transaction hash (32-byte string).
+* **`nonce`** - The number of transactions sent by the sender before this transaction (hexadecimal string).
+* **`blockHash`** - The block hash where the transaction is included (32-byte string).
+* **`blockNumber`** - The block number where the transaction is included (hexadecimal string).
+* **`transactionIndex`** - The index of the transaction in the block (hexadecimal string).
+* **`from`** - The sender address (20-byte string).
+* **`to`** - The recipient address, or `null` for contract creation transactions (20-byte string).
+* **`value`** - The value being transferred (hexadecimal string).
+* **`gasPrice`** - The gas price in wei (hexadecimal string).
+* **`gas`** - The gas provided for the transaction (hexadecimal string).
+* **`input`** - The input data for the transaction (byte string).
+
+### JSON-RPC Request and Response Examples
+
+Here are examples of JSON-RPC request and response for the `eth_getBlockByNumber` method:
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockByNumber",
+ "params": ["latest", true]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x2",
+ "extraData": "0xd883010114846765746888676f312e31392e36856c696e75780000008279af9a2f9343c00920c795a7abe84303ee56588946383a15d1e9ee422a7df6dcbe199e4ec93511fe1ffa3c3ab10cb5b12459e8f64553ad3a741e9562e1d5e522c336a400",
+ "gasLimit": "0x2faed85",
+ "gasUsed": "0xd81f1",
+ "hash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "logsBloom": "0x0020001000000000000001000000000000000000000000040000000000084000000004000800000000c06100800000000000000000010000200000000024008000004000000000000000001800001000a050000000040004000000000000000000000220020200000000000000400800080008000000000000001010004000400000000000010000000000000000000000002400000008000000008000000021022000000000000000000000000000000000000000000000000000000000010010180003000800000000000000000000000000800000000020000082000060000010000000001002010800000000000000020000080000800000000000000000",
+ "miner": "0x35552c16704d214347f29fa77f77da6d75d7c752",
+ "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "nonce": "0x0000000000000000",
+ "number": "0x1b5dd23",
+ "parentHash": "0x41f85649fa6d5e58a4631f76724a96dba8313302323f0834b9cf2b63d0308e0f",
+ "receiptsRoot": "0x81835f75c1f7521016ce3404f19a44f10c4d56b6ab780fad3388d490c154afbe",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x8e9",
+ "stateRoot": "0xda34eefae13e5940f564f3f6cc63c96fb9a0ee015b66552f01a14c2b002b0f7f",
+ "timestamp": "0x642ea5d2",
+ "totalDifficulty": "0x36908d2",
+ "transactions": [
+ {
+ "blockHash": "0x078610ca461480e4b78557f20e544084cccc4accb41f5c1b7ef792246b78c94b",
+ "blockNumber": "0x1b5dd23",
+ "from": "0xaa25aa7a19f9c426e07dee59b12f944f4d9f1dd3",
+ "gas": "0x5208",
+ "gasPrice": "0x430e23400",
+ "hash": "0x82544cc4cf767ec9d235f2afa72af2cf468b25c682c302b76390cf0830006174",
+ "input": "0x",
+ "nonce": "0x87bf4f",
+ "to": "0x2fc9076c0ebfa453dee1649721010764cbdf18fc",
+ "transactionIndex": "0x0",
+ "value": "0x16345785d8a0000",
+ "type": "0x0",
+ "v": "0xe5",
+ "r": "0x282c0953168acda79a7ec86be5392370bbce08441aa803be0576dfa467a46329",
+ "s": "0x59e528253c8fe85e72c43d84dd13d6fe724899cf3f94c4800761f2414b2b8f1e"
+ }
+ ],
+ "transactionsRoot": "0xc6939e1f42fa4c4a264a1c1617cc0a6ac7122f3cb5c2848e53b3fba35b33f6ad",
+ "uncles": []
+ }
+}
+```
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
new file mode 100644
index 0000000..97d8926
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblocktransactioncountbyhash.md
@@ -0,0 +1,70 @@
+# eth\_getBlockTransactionCountByHash
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ}
+
+const response = await tatum.rpc.getBlockTransactionCountByHash('0xF07355D9A980F61915B53A74AFCDB89598E54EFCD9DF5A9935D16BC1DC4CFA8F')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+`eth_getBlockTransactionCountByHash` is an Haqq RPC method used to fetch the number of transactions in a block by the block's hash. It is useful when you want to know the total number of transactions included in a specific block and don't want to retrieve the entire block data. This method can be used in various scenarios, such as monitoring the network activity or estimating transaction confirmation times.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/wvQVbyY" %}
+
+### Parameters
+
+This method requires a single parameter:
+
+* **`blockHash`**: The hash of the target block for which the transaction count will be retrieved. It should be a valid 32-byte hex string.
+
+Example of the parameter:
+
+* `blockHash`: `"0xF07355D9A980F61915B53A74AFCDB89598E54EFCD9DF5A9935D16BC1DC4CFA8F"`
+
+### Return
+
+The method returns a single value:
+
+* `transactionCount`: The total number of transactions included in the specified block. It is returned as a hexadecimal value.
+
+### Examples
+
+#### JSON-RPC request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getBlockTransactionCountByHash",
+ "params": [
+ "0xF07355D9A980F61915B53A74AFCDB89598E54EFCD9DF5A9935D16BC1DC4CFA8F"
+ ]
+}
+```
+
+#### JSON-RPC response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0xa"
+}
+```
+
+In this example, the block with the hash `"0xF07355D9A980F61915B53A74AFCDB89598E54EFCD9DF5A9935D16BC1DC4CFA8F"` has a total of 10 transactions (indicated by the hexadecimal value `"0xa"`).
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
new file mode 100644
index 0000000..b10c26e
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getblocktransactioncountbynumber.md
@@ -0,0 +1,65 @@
+# eth\_getBlockTransactionCountByNumber
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ}
+
+const response = await tatum.rpc.getBlockTransactionCountByNumber(7687453)
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getBlockTransactionCountByNumber` Haqq JSON-RPC method allows you to retrieve the number of transactions in a specified block. This method is particularly useful when you need to analyze the transaction activity of a specific block. You can use it to gain insights into network usage, analyze the impact of specific events on the Haqq network, or monitor transaction congestion in certain blocks.
+
+### Parameters
+
+1. **`blockNumber`**: The block number for which the transaction count should be retrieved. It should be a hex-encoded value representing the block number.
+ * Example: 7687453
+
+{% embed url="https://codepen.io/tatum-devrel/pen/YzRmbaE" %}
+
+### Return Object
+
+The return object is a hex-encoded value representing the number of transactions in the specified block.
+
+* Example: `"0xa"` (10 transactions)
+
+### JSON-RPC Request and Response Examples
+
+#### Request
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "method": "eth_getBlockTransactionCountByNumber",
+ "params": [7687453]
+}
+```
+
+#### Response
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": "0xa"
+}
+```
+
+
+
+\
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getcode.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getcode.md
new file mode 100644
index 0000000..b864939
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getcode.md
@@ -0,0 +1,77 @@
+# eth\_getCode
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ}
+
+const code = await tatum.rpc.getCode('0x2C5B9a513bE2240e948a631bAaFB53cc0bEAcfda')
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getCode` method is part of the Haqq JSON-RPC API, which allows users to interact with the Haqq blockchain. This method is specifically used to retrieve the contract code (bytecode) of an account at a specific block number. It is helpful when developers need to examine the bytecode of a deployed contract or validate that the contract code on the blockchain matches the intended code.
+
+Use cases for this method could include:
+
+* Debugging a smart contract
+* Verifying the integrity of a deployed contract
+* Analyzing contract bytecode for security vulnerabilities
+
+{% embed url="https://codepen.io/tatum-devrel/pen/rNQXgJV" %}
+
+### Parameters
+
+The `eth_getCode` method accepts two parameters:
+
+1. **`address`** (string): The address of the contract whose bytecode you want to retrieve. This should be a 20-byte Haqq address, formatted as a hex string with a `0x` prefix.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`block`** (string): The block number at which you want to retrieve the contract code. This can be specified as a hex string or one of the following special keywords:
+ * `"earliest"`: The first block in the blockchain
+ * `"latest"`: The most recent block in the blockchain
+ * `"pending"`: The upcoming block that is being mined
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The `eth_getCode` method returns a string representing the contract bytecode. The returned value is a hex string with a `0x` prefix.
+
+* If the account has contract code, the returned string will contain the bytecode.
+* If the account is not a contract or does not exist, the returned string will be `0x`.
+
+### JSON Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getCode",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "latest"
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": "0x606060...code_here...3839"
+}
+```
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getlogs.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getlogs.md
new file mode 100644
index 0000000..aa638fa
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getlogs.md
@@ -0,0 +1,113 @@
+# eth\_getLogs
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ}
+
+const logs = await tatum.rpc.getLogs({ address : '0x2C5B9a513bE2240e948a631bAaFB53cc0bEAcfda'})
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getLogs` method is an Haqq JSON-RPC method that allows developers to query logs generated by the Haqq network, specifically event logs emitted by smart contracts. These logs are an essential part of the Haqq ecosystem as they provide a way for developers to monitor contract events and track contract state changes.
+
+This method is particularly useful when building decentralized applications (dApps) that rely on events emitted by smart contracts, as it enables developers to retrieve logs based on specific filter criteria. By using `eth_getLogs`, developers can efficiently track and react to events happening on the Haqq blockchain.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/JjegqMb" %}
+
+### Parameters
+
+The `eth_getLogs` method takes a single input parameter: an object containing the filter criteria. The filter object can have the following fields:
+
+* **`fromBlock`**: (optional) The starting block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"fromBlock": "0x1"`
+* **`toBlock`**: (optional) The ending block number for the search. Can be a block number or one of the following strings: `"earliest"`, `"latest"`, or `"pending"`.
+ * Example: `"toBlock": "0x2"`
+* **`address`**: (optional) The address or list of addresses of the contracts to filter logs from. Can be a single address or an array of addresses.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`topics`**: (optional) An array of up to four 32-byte topics. Topics are order-dependent, and each topic can be an array of topic hashes or `null`.
+ * Example: `"topics": ["0x123..."]`
+* **`blockhash`**: (optional) The block hash to filter logs from. If provided, `fromBlock` and `toBlock` are ignored.
+ * Example: `"blockhash": "0xc6ef9..."`
+
+In addition to the above fields, the `transactions` field in the filter object can be specified to include full transaction details instead of just transaction hashes. This is useful when you need more information about the transactions in which the events were emitted.
+
+### Return Object
+
+The `eth_getLogs` method returns an array of log objects. Each log object contains the following fields:
+
+* **`removed`**: A boolean indicating whether the log was removed due to a chain reorganization.
+ * Example: `"removed": false`
+* **`logIndex`**: The log index position in the block.
+ * Example: `"logIndex": "0x1"`
+* **`transactionIndex`**: The transaction index position in the block.
+ * Example: `"transactionIndex": "0x0"`
+* **`transactionHash`**: The hash of the transaction that emitted the log.
+ * Example: `"transactionHash": "0x88eef..."`
+* **`blockHash`**: The hash of the block containing the log.
+ * Example: `"blockHash": "0xc6ef9..."`
+* **`blockNumber`**: The block number containing the log.
+ * Example: `"blockNumber": "0x1"`
+* **`address`**: The address of the contract that emitted the log.
+ * Example: `"address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+* **`data`**: The data associated with the log.
+ * Example: `"data":"0x0000000000000000000000000000000000000000000000000000000000000020"`
+* **`topics`**: An array of topics (order-dependent) associated with the log.
+ * Example: `"topics": ["0x123..."]`
+
+## JSON-RPC Examples
+
+#### Request
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getLogs",
+ "params": [
+ {
+ "fromBlock": "0x1",
+ "toBlock": "0x2",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+#### Response
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": [
+ {
+ "removed": false,
+ "logIndex": "0x1",
+ "transactionIndex": "0x0",
+ "transactionHash": "0x88eef...",
+ "blockHash": "0xc6ef9...",
+ "blockNumber": "0x1",
+ "address": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ "data": "0x0000000000000000000000000000000000000000000000000000000000000020",
+ "topics": ["0x123..."]
+ }
+ ]
+}
+```
+
+This documentation provides a comprehensive overview of the `eth_getLogs` Haqq JSON-RPC method, its parameters, return objects, and JSON-RPC examples. By using this method, developers can effectively query logs generated by the Haqq network and use the retrieved data to track and react to events happening on the Haqq blockchain.
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getproof.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getproof.md
new file mode 100644
index 0000000..fc0f0a9
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getproof.md
@@ -0,0 +1,109 @@
+# eth\_getProof
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network} from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init({network: Network.HAQQ})
+
+const result = await tatum.rpc.getProof("0x2C5B9a513bE2240e948a631bAaFB53cc0bEAcfda",
+ ["0x0000000000000000000000000000000000000000000000000000000000000000"],
+ "latest")
+
+tatum.destroy() // Destroy Tatum SDK - needed for stopping background jobs
+```
+{% endcode %}
+{% endtab %}
+{% endtabs %}
+
+### Overview
+
+The `eth_getProof` is an Haqq JSON-RPC method that retrieves the Merkle-Patricia proof for an account, storage key-value pairs, and account transaction count. It allows developers to verify the state of an account or storage value at a specific block without needing the entire Haqq state trie. This method is particularly useful for light clients or off-chain applications that require proof of an account's state or specific storage values.
+
+{% embed url="https://codepen.io/tatum-devrel/pen/poQMmVM" %}
+
+### Parameters
+
+1. **`address`** - `Data`, 20 Bytes
+ * The address of the account.
+ * Example: `"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"`
+2. **`keys`** - `Array` of `Data`
+ * An array of storage keys for which the proof should be generated.
+ * Example: `["0x0000000000000000000000000000000000000000000000000000000000000000"]`
+3. **`blockNumber`** - `Quantity` or `String`
+ * The block number for which the proof should be generated.
+ * Example: `"0x1"` or `"latest"`
+
+### Return Object
+
+The method returns an object containing the following fields:
+
+1. **`accountProof`** - `Array` of `Data`
+ * The serialized Merkle-Patricia proof for the account.
+2. **`balance`** - `Quantity`
+ * The balance of the account at the specified block.
+3. **`codeHash`** - `Data`, 32 Bytes
+ * The hash of the code for the account at the specified block.
+4. **`nonce`** - `Quantity`
+ * The transaction count of the account at the specified block.
+5. **`storageProof`** - `Array` of `Object`
+ * An array of storage proof objects, one for each requested key, containing the following fields:
+ * `key` - `Data`, 32 Bytes: The storage key.
+ * `value` - `Quantity`: The storage value.
+ * `proof` - `Array` of `Data`: The serialized Merkle-Patricia proof for the key-value pair.
+
+### JSON-RPC Request and Response Examples
+
+_Request_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "method": "eth_getProof",
+ "params": [
+ "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+ [
+ "0x0000000000000000000000000000000000000000000000000000000000000000"
+ ],
+ "latest"
+ ]
+}
+```
+
+_Response_:
+
+```json
+{
+ "id": 1,
+ "jsonrpc": "2.0",
+ "result": {
+ "accountProof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ],
+ "balance": "0xde0b6b3a7640000",
+ "codeHash": "0x...",
+ "nonce": "0x1",
+ "storageProof": [
+ {
+ "key": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "value": "0xde0b6b3a7640000",
+ "proof": [
+ "0x...",
+ "0x...",
+ "0x..."
+ ]
+ }
+ ]
+ }
+}
+
+```
diff --git a/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getstorageat.md b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getstorageat.md
new file mode 100644
index 0000000..9dda701
--- /dev/null
+++ b/docs/rpc/evm-blockchains/haqq-rpc-documentation/network-state/eth_getstorageat.md
@@ -0,0 +1,71 @@
+# eth\_getStorageAt
+
+### How to use it
+
+{% tabs %}
+{% tab title="TypeScript/JavaScript" %}
+{% code overflow="wrap" lineNumbers="true" %}
+```typescript
+// yarn add @tatumio/tatum
+
+import { TatumSDK, Haqq, Network } from '@tatumio/tatum'
+
+const tatum = await TatumSDK.init