> ## Documentation Index
> Fetch the complete documentation index at: https://docs.therootnetwork.com/llms.txt
> Use this file to discover all available pages before exploring further.
# JSON-RPC
## Author
### `hasKey`
Returns true if the keystore has private keys for the given public key and key type.
This method is only active with appropriate flags.
**Interface**
```ts
api.rpc.author.hasKey(publicKey: Bytes, keyType: Text): bool
```
**JSON**
```ts
{ "id":1, "jsonrpc":"2.0", "method":"author_hasKey", "params":[publicKey: Bytes, keyType: Text] }
```
### `hasSessionKeys`
Returns true if the keystore has private keys for the given session public keys.
This method is only active with appropriate flags.
**Interface**
```ts
api.rpc.author.hasSessionKeys(sessionKeys: Bytes): bool
```
**JSON**
```ts
{ "id":1, "jsonrpc":"2.0", "method":"author_hasSessionKeys", "params":[sessionKeys: Bytes] }
```
### `insertKey`
Insert a key into the keystore.
This method is only active with appropriate flags.
**Interface**
```ts
api.rpc.author.insertKey(keyType: Text, suri: Text, publicKey: Bytes): Bytes
```
**JSON**
```ts
{ "id":1, "jsonrpc":"2.0", "method":"author_insertKey", "params":[keyType: Text, suri: Text, publicKey: Bytes] }
```
### `pendingExtrinsics`
Returns all pending extrinsics, potentially grouped by sender
**Interface**
```ts
api.rpc.author.pendingExtrinsics(): Vec
```
**JSON**
```ts
{ "id":1, "jsonrpc":"2.0", "method":"author_pendingExtrinsics", "params":[] }
```
### `removeExtrinsic`
Remove given extrinsic from the pool and temporarily ban it to prevent reimporting
This method is only active with appropriate flags.
**Interface**
```ts
api.rpc.author.removeExtrinsic(bytesOrHash: Vec): Vec
```
**JSON**
```ts
{ "id":1, "jsonrpc":"2.0", "method":"author_removeExtrinsic", "params":[bytesOrHash: Vec] }
```
### `rotateKeys`
Generate new session keys and returns the corresponding public keys
This method is only active with appropriate flags.
**Interface**
```
api.rpc.author.rotateKeys(): Bytes
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"author_rotateKeys", "params":[] }
```
### `submitAndWatchExtrinsic`
Submit and subscribe to watch an extrinsic until unsubscribed
**Interface**
```
api.rpc.author.submitAndWatchExtrinsic(extrinsic: Extrinsic): ExtrinsicStatus
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"author_submitAndWatchExtrinsic", "params":[extrinsic: Extrinsic] }
```
### `submitExtrinsic`
Submit a fully formatted extrinsic for block inclusion
**Interface**
```
api.rpc.author.submitExtrinsic(extrinsic: Extrinsic): Hash
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"author_submitExtrinsic", "params":[extrinsic: Extrinsic] }
```
## Babe
### `epochAuthorship`
Returns data about which slots (primary or secondary) can be claimed in the current epoch with the keys in the keystore
This method is only active with appropriate flags.
**Interface**
```
api.rpc.babe.epochAuthorship(): HashMap
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"babe_epochAuthorship", "params":[] }
```
## Chain
### `getBlock`
Get header and body of a relay chain block
**Interface**
```
api.rpc.chain.getBlock(hash?: BlockHash): SignedBlock
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"chain_getBlock", "params":[hash?: BlockHash] }
```
### `getBlockHash`
Get the block hash for a specific block
**Interface**
```
api.rpc.chain.getBlockHash(blockNumber?: BlockNumber): BlockHash
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"chain_getBlockHash", "params":[blockNumber?: BlockNumber] }
```
### `getFinalizedHead`
Get hash of the last finalized block in the canon chain
**Interface**
```
api.rpc.chain.getFinalizedHead(): BlockHash
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"chain_getFinalizedHead", "params":[] }
```
### `getHeader`
Retrieves the header for a specific block
**Interface**
```
api.rpc.chain.getHeader(hash?: BlockHash): Header
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"chain_getHeader", "params":[hash?: BlockHash] }
```
### `subscribeAllHeads`
Retrieves the newest header via subscription
**Interface**
```
api.rpc.chain.subscribeAllHeads(): Header
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"chain_subscribeAllHeads", "params":[] }
```
### `subscribeFinalizedHeads`
Retrieves the best finalized header via subscription
**Interface**
```
api.rpc.chain.subscribeFinalizedHeads(): Header
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"chain_subscribeFinalizedHeads", "params":[] }
```
### `subscribeNewHeads`
Retrieves the best header via subscription
**Interface**
```
api.rpc.chain.subscribeNewHeads(): Header
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"chain_subscribeNewHeads", "params":[] }
```
## Childstate
### `getKeys`
Returns the keys with prefix from a child storage, leave empty to get all the keys
**Interface**
```
api.rpc.childstate.getKeys(childKey: PrefixedStorageKey, prefix: StorageKey, at?: Hash): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"childstate_getKeys", "params":[childKey: PrefixedStorageKey, prefix: StorageKey, at?: Hash] }
```
### `getKeysPaged`
Returns the keys with prefix from a child storage with pagination support
**Interface**
```
api.rpc.childstate.getKeysPaged(childKey: PrefixedStorageKey, prefix: StorageKey, count: u32, startKey?: StorageKey, at?: Hash): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"childstate_getKeysPaged", "params":[childKey: PrefixedStorageKey, prefix: StorageKey, count: u32, startKey?: StorageKey, at?: Hash] }
```
### `getStorage`
Returns a child storage entry at a specific block state
**Interface**
```
api.rpc.childstate.getStorage(childKey: PrefixedStorageKey, key: StorageKey, at?: Hash): Option
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"childstate_getStorage", "params":[childKey: PrefixedStorageKey, key: StorageKey, at?: Hash] }
```
### `getStorageEntries`
Returns child storage entries for multiple keys at a specific block state
**Interface**
```
api.rpc.childstate.getStorageEntries(childKey: PrefixedStorageKey, keys: Vec, at?: Hash): Vec>
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"childstate_getStorageEntries", "params":[childKey: PrefixedStorageKey, keys: Vec, at?: Hash] }
```
### `getStorageHash`
Returns the hash of a child storage entry at a block state
**Interface**
```
api.rpc.childstate.getStorageHash(childKey: PrefixedStorageKey, key: StorageKey, at?: Hash): Option
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"childstate_getStorageHash", "params":[childKey: PrefixedStorageKey, key: StorageKey, at?: Hash] }
```
### `getStorageSize`
Returns the size of a child storage entry at a block state
**Interface**
```
api.rpc.childstate.getStorageSize(childKey: PrefixedStorageKey, key: StorageKey, at?: Hash): Option
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"childstate_getStorageSize", "params":[childKey: PrefixedStorageKey, key: StorageKey, at?: Hash] }
```
## Dex
### `getAmountsIn`
Given an array of AssetIds, return amounts in for an amount out
**Interface**
```
api.rpc.dex.getAmountsIn(amountOut: u128, path: Vec): Json
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"dex_getAmountsIn", "params":[amountOut: u128, path: Vec] }
```
### `getAmountsOut`
Given an array of AssetIds, return amounts out for an amount in
**Interface**
```
api.rpc.dex.getAmountsOut(amountIn: u128, path: Vec): Json
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"dex_getAmountsOut", "params":[amountIn: u128, path: Vec] }
```
### `getLPTokenID`
Given two AssetIds, return liquidity token created for the pair
**Interface**
```
api.rpc.dex.getLPTokenID(assetA: AssetId, assetB: AssetId): Json
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"dex_getLPTokenID", "params":[assetA: AssetId, assetB: AssetId] }
```
### `getLiquidity`
Given two AssetIds, return liquidity
**Interface**
```
api.rpc.dex.getLiquidity(assetA: AssetId, assetB: AssetId): Json
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"dex_getLiquidity", "params":[assetA: AssetId, assetB: AssetId] }
```
### `getTradingPairStatus`
Given two AssetIds, return whether trading pair is enabled or disabled
**Interface**
```
api.rpc.dex.getTradingPairStatus(assetA: AssetId, assetB: AssetId): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"dex_getTradingPairStatus", "params":[assetA: AssetId, assetB: AssetId] }
```
### `quote`
Given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
**Interface**
```
api.rpc.dex.quote(amountA: u128, reserveA: u128, reserveB: u128): Json
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"dex_quote", "params":[amountA: u128, reserveA: u128, reserveB: u128] }
```
## Eth
### `accounts`
Returns accounts list.
**Interface**
```
api.rpc.eth.accounts(): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_accounts", "params":[] }
```
### `blockNumber`
Returns the blockNumber
**Interface**
```
api.rpc.eth.blockNumber(): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_blockNumber", "params":[] }
```
### `call`
Call contract, returning the output data.
**Interface**
```
api.rpc.eth.call(request: EthCallRequest, number?: BlockNumber): Bytes
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_call", "params":[request: EthCallRequest, number?: BlockNumber] }
```
### `chainId`
Returns the chain ID used for transaction signing at the current best block. None is returned if not available.
**Interface**
```
api.rpc.eth.chainId(): U64
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_chainId", "params":[] }
```
### `coinbase`
Returns block author.
**Interface**
```
api.rpc.eth.coinbase(): H160
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_coinbase", "params":[] }
```
### `estimateGas`
Estimate gas needed for execution of given contract.
**Interface**
```
api.rpc.eth.estimateGas(request: EthCallRequest, number?: BlockNumber): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_estimateGas", "params":[request: EthCallRequest, number?: BlockNumber] }
```
### `feeHistory`
Returns fee history for given block count & reward percentiles
**Interface**
```
api.rpc.eth.feeHistory(blockCount: U256, newestBlock: BlockNumber, rewardPercentiles: Option>): EthFeeHistory
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_feeHistory", "params":[blockCount: U256, newestBlock: BlockNumber, rewardPercentiles: Option>] }
```
### `gasPrice`
Returns current gas price.
**Interface**
```
api.rpc.eth.gasPrice(): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_gasPrice", "params":[] }
```
### `getBalance`
Returns balance of the given account.
**Interface**
```
api.rpc.eth.getBalance(address: H160, number?: BlockNumber): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getBalance", "params":[address: H160, number?: BlockNumber] }
```
### `getBlockByHash`
Returns block with given hash.
**Interface**
```
api.rpc.eth.getBlockByHash(hash: H256, full: bool): Option
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getBlockByHash", "params":[hash: H256, full: bool] }
```
### `getBlockByNumber`
Returns block with given number.
**Interface**
```
api.rpc.eth.getBlockByNumber(block: BlockNumber, full: bool): Option
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getBlockByNumber", "params":[block: BlockNumber, full: bool] }
```
### `getBlockTransactionCountByHash`
Returns the number of transactions in a block with given hash.
**Interface**
```
api.rpc.eth.getBlockTransactionCountByHash(hash: H256): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getBlockTransactionCountByHash", "params":[hash: H256] }
```
### `getBlockTransactionCountByNumber`
Returns the number of transactions in a block with given block number.
**Interface**
```
api.rpc.eth.getBlockTransactionCountByNumber(block: BlockNumber): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getBlockTransactionCountByNumber", "params":[block: BlockNumber] }
```
### `getCode`
Returns the code at given address at given time (block number).
**Interface**
```
api.rpc.eth.getCode(address: H160, number?: BlockNumber): Bytes
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getCode", "params":[address: H160, number?: BlockNumber] }
```
### `getFilterChanges`
Returns filter changes since last poll.
**Interface**
```
api.rpc.eth.getFilterChanges(index: U256): EthFilterChanges
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getFilterChanges", "params":[index: U256] }
```
### `getFilterLogs`
Returns all logs matching given filter (in a range 'from' - 'to').
**Interface**
```
api.rpc.eth.getFilterLogs(index: U256): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getFilterLogs", "params":[index: U256] }
```
### `getLogs`
Returns logs matching given filter object.
**Interface**
```
api.rpc.eth.getLogs(filter: EthFilter): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getLogs", "params":[filter: EthFilter] }
```
### `getStorageAt`
Returns content of the storage at given address.
**Interface**
```
api.rpc.eth.getStorageAt(address: H160, index: U256, number?: BlockNumber): H256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getStorageAt", "params":[address: H160, index: U256, number?: BlockNumber] }
```
### `getTransactionByBlockHashAndIndex`
Returns transaction at given block hash and index.
**Interface**
```
api.rpc.eth.getTransactionByBlockHashAndIndex(hash: H256, index: U256): EthTransaction
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getTransactionByBlockHashAndIndex", "params":[hash: H256, index: U256] }
```
### `getTransactionByBlockNumberAndIndex`
Returns transaction by given block number and index.
**Interface**
```
api.rpc.eth.getTransactionByBlockNumberAndIndex(number: BlockNumber, index: U256): EthTransaction
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getTransactionByBlockNumberAndIndex", "params":[number: BlockNumber, index: U256] }
```
### `getTransactionByHash`
Get transaction by its hash.
**Interface**
```
api.rpc.eth.getTransactionByHash(hash: H256): EthTransaction
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getTransactionByHash", "params":[hash: H256] }
```
### `getTransactionCount`
Returns the number of transactions sent from given address at given time (block number).
**Interface**
```
api.rpc.eth.getTransactionCount(address: H160, number?: BlockNumber): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getTransactionCount", "params":[address: H160, number?: BlockNumber] }
```
### `getTransactionReceipt`
Returns transaction receipt by transaction hash.
**Interface**
```
api.rpc.eth.getTransactionReceipt(hash: H256): EthReceipt
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getTransactionReceipt", "params":[hash: H256] }
```
### `getUncleByBlockHashAndIndex`
Returns an uncles at given block and index.
**Interface**
```
api.rpc.eth.getUncleByBlockHashAndIndex(hash: H256, index: U256): EthRichBlock
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getUncleByBlockHashAndIndex", "params":[hash: H256, index: U256] }
```
### `getUncleByBlockNumberAndIndex`
Returns an uncles at given block and index.
**Interface**
```
api.rpc.eth.getUncleByBlockNumberAndIndex(number: BlockNumber, index: U256): EthRichBlock
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getUncleByBlockNumberAndIndex", "params":[number: BlockNumber, index: U256] }
```
### `getUncleCountByBlockHash`
Returns the number of uncles in a block with given hash.
**Interface**
```
api.rpc.eth.getUncleCountByBlockHash(hash: H256): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getUncleCountByBlockHash", "params":[hash: H256] }
```
### `getUncleCountByBlockNumber`
Returns the number of uncles in a block with given block number.
**Interface**
```
api.rpc.eth.getUncleCountByBlockNumber(number: BlockNumber): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getUncleCountByBlockNumber", "params":[number: BlockNumber] }
```
### `getWork`
Returns the hash of the current block, the seedHash, and the boundary condition to be met.
**Interface**
```
api.rpc.eth.getWork(): EthWork
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_getWork", "params":[] }
```
### `hashrate`
Returns the number of hashes per second that the node is mining with.
**Interface**
```
api.rpc.eth.hashrate(): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_hashrate", "params":[] }
```
### `maxPriorityFeePerGas`
Returns max priority fee per gas
**Interface**
```
api.rpc.eth.maxPriorityFeePerGas(): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_maxPriorityFeePerGas", "params":[] }
```
### `mining`
Returns true if client is actively mining new blocks.
**Interface**
```
api.rpc.eth.mining(): bool
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_mining", "params":[] }
```
### `newBlockFilter`
Returns id of new block filter.
**Interface**
```
api.rpc.eth.newBlockFilter(): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_newBlockFilter", "params":[] }
```
### `newFilter`
Returns id of new filter.
**Interface**
```
api.rpc.eth.newFilter(filter: EthFilter): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_newFilter", "params":[filter: EthFilter] }
```
### `newPendingTransactionFilter`
Returns id of new block filter.
**Interface**
```
api.rpc.eth.newPendingTransactionFilter(): U256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_newPendingTransactionFilter", "params":[] }
```
### `protocolVersion`
Returns protocol version encoded as a string (quotes are necessary).
**Interface**
```
api.rpc.eth.protocolVersion(): u64
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_protocolVersion", "params":[] }
```
### `sendRawTransaction`
Sends signed transaction, returning its hash.
**Interface**
```
api.rpc.eth.sendRawTransaction(bytes: Bytes): H256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_sendRawTransaction", "params":[bytes: Bytes] }
```
### `sendTransaction`
Sends transaction; will block waiting for signer to return the transaction hash
**Interface**
```
api.rpc.eth.sendTransaction(tx: EthTransactionRequest): H256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_sendTransaction", "params":[tx: EthTransactionRequest] }
```
### `submitHashrate`
Used for submitting mining hashrate.
**Interface**
```
api.rpc.eth.submitHashrate(index: U256, hash: H256): bool
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_submitHashrate", "params":[index: U256, hash: H256] }
```
### `submitWork`
Used for submitting a proof-of-work solution.
**Interface**
```
api.rpc.eth.submitWork(nonce: H64, headerHash: H256, mixDigest: H256): bool
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_submitWork", "params":[nonce: H64, headerHash: H256, mixDigest: H256] }
```
### `subscribe`
Subscribe to Eth subscription.
**Interface**
```
api.rpc.eth.subscribe(kind: EthSubKind, params?: EthSubParams): Null
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_subscribe", "params":[kind: EthSubKind, params?: EthSubParams] }
```
### `syncing`
Returns an object with data about the sync status or false.
**Interface**
```
api.rpc.eth.syncing(): EthSyncStatus
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_syncing", "params":[] }
```
### `uninstallFilter`
Uninstalls filter.
**Interface**
```
api.rpc.eth.uninstallFilter(index: U256): bool
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"eth_uninstallFilter", "params":[index: U256] }
```
## Ethy
### `getEventProof`
Get ETH event proof for event Id
**Interface**
```
api.rpc.ethy.getEventProof(eventId: EventProofId): Option
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"ethy_getEventProof", "params":[eventId: EventProofId] }
```
### `getXrplTxProof`
Get XRPL event proof for event Id
**Interface**
```
api.rpc.ethy.getXrplTxProof(eventId: EventProofId): Option
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"ethy_getXrplTxProof", "params":[eventId: EventProofId] }
```
## Grandpa
### `proveFinality`
Prove finality for the given block number, returning the Justification for the last block in the set.
**Interface**
```
api.rpc.grandpa.proveFinality(blockNumber: BlockNumber): Option
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"grandpa_proveFinality", "params":[blockNumber: BlockNumber] }
```
### `roundState`
Returns the state of the current best round state as well as the ongoing background rounds
**Interface**
```
api.rpc.grandpa.roundState(): ReportedRoundStates
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"grandpa_roundState", "params":[] }
```
### `subscribeJustifications`
Subscribes to grandpa justifications
**Interface**
```
api.rpc.grandpa.subscribeJustifications(): JustificationNotification
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"grandpa_subscribeJustifications", "params":[] }
```
## Net
### `listening`
Returns true if client is actively listening for network connections. Otherwise false.
**Interface**
```
api.rpc.net.listening(): bool
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"net_listening", "params":[] }
```
### `peerCount`
Returns number of peers connected to node.
**Interface**
```
api.rpc.net.peerCount(): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"net_peerCount", "params":[] }
```
### `version`
Returns protocol version.
**Interface**
```
api.rpc.net.version(): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"net_version", "params":[] }
```
## Nft
### `ownedTokens`
Get all NFTs owned by an account
**Interface**
```
api.rpc.nft.ownedTokens(collectionId: CollectionUuid, who: AccountId, cursor: SerialNumber, limit: u16): Json
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"nft_ownedTokens", "params":[collectionId: CollectionUuid, who: AccountId, cursor: SerialNumber, limit: u16] }
```
### `tokenUri`
Get the URI of a token
**Interface**
```
api.rpc.nft.tokenUri(tokenId: TokenId): Json
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"nft_tokenUri", "params":[tokenId: TokenId] }
```
## Offchain
### `localStorageGet`
Get offchain local storage under given key and prefix
This method is only active with appropriate flags
**Interface**
```
api.rpc.offchain.localStorageGet(kind: StorageKind, key: Bytes): Option
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"offchain_localStorageGet", "params":[kind: StorageKind, key: Bytes] }
```
### `localStorageSet`
Set offchain local storage under given key and prefix
This method is only active with appropriate flags
**Interface**
```
api.rpc.offchain.localStorageSet(kind: StorageKind, key: Bytes, value: Bytes): Null
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"offchain_localStorageSet", "params":[kind: StorageKind, key: Bytes, value: Bytes] }
```
## Payment
### `queryFeeDetails`
Query the detailed fee of a given encoded extrinsic
**Interface**
```
api.rpc.payment.queryFeeDetails(extrinsic: Bytes, at?: BlockHash): FeeDetails
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"payment_queryFeeDetails", "params":[extrinsic: Bytes, at?: BlockHash] }
```
**Deprecated Use** `api.call.transactionPaymentApi.queryFeeDetails` **instead**
### `queryInfo`
Retrieves the fee information for an encoded extrinsic
**Interface**
```
api.rpc.payment.queryInfo(extrinsic: Bytes, at?: BlockHash): RuntimeDispatchInfoV1
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"payment_queryInfo", "params":[extrinsic: Bytes, at?: BlockHash] }
```
**Deprecated Use** `api.call.transactionPaymentApi.queryInfo` **instead**
## Rpc
### `methods`
Retrieves the list of RPC methods that are exposed by the node
**Interface**
```
api.rpc.rpc.methods(): RpcMethods
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"rpc_methods", "params":[] }
```
## State
### `call`
Perform a call to a builtin on the chain
**Interface**
```
api.rpc.state.call(method: Text, data: Bytes, at?: BlockHash): Bytes
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_call", "params":[method: Text, data: Bytes, at?: BlockHash] }
```
### `getChildReadProof`
Returns proof of storage for child key entries at a specific block state.
**Interface**
```
api.rpc.state.getChildReadProof(childStorageKey: PrefixedStorageKey, keys: Vec, at?: BlockHash): ReadProof
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getChildReadProof", "params":[childStorageKey: PrefixedStorageKey, keys: Vec, at?: BlockHash] }
```
### `getKeys`
Retrieves the keys with a certain prefix
**Interface**
```
api.rpc.state.getKeys(key: StorageKey, at?: BlockHash): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getKeys", "params":[key: StorageKey, at?: BlockHash] }
```
**Deprecated Use** `api.rpc.state.getKeysPaged` **to retrieve keys**
### `getKeysPaged`
Returns the keys with prefix with pagination support.
**Interface**
```
api.rpc.state.getKeysPaged(key: StorageKey, count: u32, startKey?: StorageKey, at?: BlockHash): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getKeysPaged", "params":[key: StorageKey, count: u32, startKey?: StorageKey, at?: BlockHash] }
```
### `getMetadata`
Returns the runtime metadata
**Interface**
```
api.rpc.state.getMetadata(at?: BlockHash): Metadata
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getMetadata", "params":[at?: BlockHash] }
```
### `getPairs`
Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)
This method is only active with appropriate flags
**Interface**
```
api.rpc.state.getPairs(prefix: StorageKey, at?: BlockHash): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getPairs", "params":[prefix: StorageKey, at?: BlockHash] }
```
**Deprecated Use** `api.rpc.state.getKeysPaged` **to retrieve keys**
### `getReadProof`
Returns proof of storage entries at a specific block state
**Interface**
```
api.rpc.state.getReadProof(keys: Vec, at?: BlockHash): ReadProof
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getReadProof", "params":[keys: Vec, at?: BlockHash] }
```
### `getRuntimeVersion`
Get the runtime version
**Interface**
```
api.rpc.state.getRuntimeVersion(at?: BlockHash): RuntimeVersion
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getRuntimeVersion", "params":[at?: BlockHash] }
```
### `getStorage`
Retrieves the storage for a key
**Interface**
```
api.rpc.state.getStorage(key: StorageKey, at?: BlockHash): StorageData
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getStorage", "params":[key: StorageKey, at?: BlockHash] }
```
### `getStorageHash`
Retrieves the storage hash
**Interface**
```
api.rpc.state.getStorageHash(key: StorageKey, at?: BlockHash): Hash
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getStorageHash", "params":[key: StorageKey, at?: BlockHash] }
```
### `getStorageSize`
Retrieves the storage size
**Interface**
```
api.rpc.state.getStorageSize(key: StorageKey, at?: BlockHash): u64
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_getStorageSize", "params":[key: StorageKey, at?: BlockHash] }
```
### `queryStorage`
Query historical storage entries (by key) starting from a start block.
This method is only active with appropriate flags.
**Interface**
```
api.rpc.state.queryStorage(keys: Vec, fromBlock: Hash, toBlock?: BlockHash): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_queryStorage", "params":[keys: Vec, fromBlock: Hash, toBlock?: BlockHash] }
```
### `queryStorageAt`
Query storage entries (by key) starting at block hash given as the second parameter
**Interface**
```
api.rpc.state.queryStorageAt(keys: Vec, at?: BlockHash): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_queryStorageAt", "params":[keys: Vec, at?: BlockHash] }
```
### `subscribeRuntimeVersion`
Retrieves the runtime version via subscription
**Interface**
```
api.rpc.state.subscribeRuntimeVersion(): RuntimeVersion
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_subscribeRuntimeVersion", "params":[] }
```
### `subscribeStorage`
Subscribes to storage changes for the provided keys
**Interface**
```
api.rpc.state.subscribeStorage(keys?: Vec): StorageChangeSet
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_subscribeStorage", "params":[keys?: Vec] }
```
### `traceBlock`
Provides a way to trace the re-execution of a single block
This method is only active with appropriate flags.
**Interface**
```
api.rpc.state.traceBlock(block: Hash, targets: Option, storageKeys: Option, methods: Option): TraceBlockResponse
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"state_traceBlock", "params":[block: Hash, targets: Option, storageKeys: Option, methods: Option] }
```
## System
### `accountNextIndex`
Retrieves the next accountIndex as available on the node
**Interface**
```
api.rpc.system.accountNextIndex(accountId: AccountId): Index
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_accountNextIndex", "params":[accountId: AccountId] }
```
### `addLogFilter`
Adds the supplied directives to the current log filter.
**Info**: This method is only active with appropriate flags.
**Interface**
```
api.rpc.system.addLogFilter(directives: Text): Null
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_addLogFilter", "params":[directives: Text] }
```
### `addReservedPeer`
Adds a reserved peer
This method is only active with appropriate flags.
**Interface**
```
api.rpc.system.addReservedPeer(peer: Text): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_addReservedPeer", "params":[peer: Text] }
```
### `chain`
Retrieves the chain
**Interface**
```
api.rpc.system.chain(): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_chain", "params":[] }
```
### `chainType`
Retrieves the chain type
**Interface**
```
api.rpc.system.chainType(): ChainType
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_chainType", "params":[] }
```
### `dryRun`
Dry run an extrinsic at a given block.
This method is only active with appropriate flags.
**Interface**
```
api.rpc.system.dryRun(extrinsic: Bytes, at?: BlockHash): ApplyExtrinsicResult
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_dryRun", "params":[extrinsic: Bytes, at?: BlockHash] }
```
### `health`
Return health status of the node
**Interface**
```
api.rpc.system.health(): Health
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_health", "params":[] }
```
### `localListenAddresses`
The addresses include a trailing /p2p/ with the local PeerId, and are thus suitable to be passed to addReservedPeer or as a bootnode address for example
**Interface**
```
api.rpc.system.localListenAddresses(): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_localListenAddresses", "params":[] }
```
### `localPeerId`
Returns the base58-encoded PeerId of the node
**Interface**
```
api.rpc.system.localPeerId(): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_localPeerId", "params":[] }
```
### `name`
Retrieves the node name
**Interface**
```
api.rpc.system.name(): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_name", "params":[] }
```
### `nodeRoles`
Returns the roles the node is running as
**Interface**
```
api.rpc.system.nodeRoles(): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_nodeRoles", "params":[] }
```
### `peers`
Returns the currently connected peers.
This method is only active with appropriate flags.
**Interface**
```
api.rpc.system.peers(): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_peers", "params":[] }
```
### `properties`
Get a custom set of properties as a JSON object, defined in the chain spec
**Interface**
```
api.rpc.system.properties(): ChainProperties
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_properties", "params":[] }
```
### `removeReservedPeer`
Remove a reserved peer.
This method is only active with appropriate flags.
**Interface**
```
api.rpc.system.removeReservedPeer(peerId: Text): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_removeReservedPeer", "params":[peerId: Text] }
```
### `reservedPeers`
Returns the list of reserved peers
**Interface**
```
api.rpc.system.reservedPeers(): Vec
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_reservedPeers", "params":[] }
```
### `resetLogFilter`
Resets the log filter to Substrate defaults
This method is only active with appropriate flags.
**Interface**
```
api.rpc.system.resetLogFilter(): Null
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_resetLogFilter", "params":[] }
```
### `syncState`
Returns the state of the syncing of the node
**Interface**
```
api.rpc.system.syncState(): SyncState
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_syncState", "params":[] }
```
### `version`
Retrieves the version of the node
**Interface**
```
api.rpc.system.version(): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"system_version", "params":[] }
```
## Web3
### `clientVersion`
Returns current client version.
**Interface**
```
api.rpc.web3.clientVersion(): Text
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"web3_clientVersion", "params":[] }
```
### `sha3`
Returns sha3 of the given data
**Interface**
```
api.rpc.web3.sha3(data: Bytes): H256
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"web3_sha3", "params":[data: Bytes] }
```
## SyloDataPermissions
### `getPermissions`
Queries the pallet's storage for all available permissions
for a given set data ids that have been granted to the specified account.
The response value will include a mapping from each data id to a
vector of onchain permissions that relate to that account.It will also include
the off-chain permission reference if it exists.
Clients can use this RPC call to avoid making multiple separate queries
to onchain storage.
**Interface**
```
type PermissionReferenceRecord {
permission_record_id: String,
resolvers: Vec<(String, Vec)>,
}
type GetPermissionsResult {
permissions: Vec<(String, Vec)>,
permission_reference: Option,
}
api.rpc.syloDataPermissions.getPermissions(
dataAuthor: AccountId,
grantee: AccountId,
dataIds: Vec
): GetPermissionsResult
```
**JSON**
```
{ "id":1, "jsonrpc":"2.0", "method":"syloDataPermissions_getPermissions", "params":[dataAuthor: AccountId, grantee: AccountId, dataIds: Vec] }
```