RPC

Last updated: Sep 25, 2026

Submit a PRSubmit an issue

RPC

This page shows JSON-RPC methods available on the Subtensor node. Accessible via api.rpc.<namespace>.<method_name>.

info

Generated from Subtensor runtime spec version 470. Connected to: wss://entrypoint-finney.opentensor.ai:443

• author
• chain
• childstate
• eth
• net
• payment
• rpc
• state
• system
• web3

author

pendingExtrinsics(): Vec<Extrinsic>

• interface: api.rpc.author.pendingExtrinsics
• summary: Returns all pending extrinsics, potentially grouped by sender

submitAndWatchExtrinsic(extrinsic: Extrinsic): ExtrinsicStatus

• interface: api.rpc.author.submitAndWatchExtrinsic
• jsonrpc: subscription
• summary: Submit and subscribe to watch an extrinsic until unsubscribed

submitExtrinsic(extrinsic: Extrinsic): Hash

• interface: api.rpc.author.submitExtrinsic
• summary: Submit a fully formatted extrinsic for block inclusion

chain

getBlock(hash?: BlockHash): SignedBlock

• interface: api.rpc.chain.getBlock
• summary: Get header and body of a relay chain block

getBlockHash(blockNumber?: BlockNumber): BlockHash

• interface: api.rpc.chain.getBlockHash
• summary: Get the block hash for a specific block

getFinalizedHead(): BlockHash

• interface: api.rpc.chain.getFinalizedHead
• summary: Get hash of the last finalized block in the canon chain

getHeader(hash?: BlockHash): Header

• interface: api.rpc.chain.getHeader
• summary: Retrieves the header for a specific block

subscribeAllHeads(): Header

• interface: api.rpc.chain.subscribeAllHeads
• jsonrpc: subscription
• summary: Retrieves the newest header via subscription

subscribeFinalizedHeads(): Header

• interface: api.rpc.chain.subscribeFinalizedHeads
• jsonrpc: subscription
• summary: Retrieves the best finalized header via subscription

subscribeNewHeads(): Header

• interface: api.rpc.chain.subscribeNewHeads
• jsonrpc: subscription
• summary: Retrieves the best header via subscription

childstate

getKeys(childKey: PrefixedStorageKey, prefix: StorageKey, at?: Hash): Vec<StorageKey>

• interface: api.rpc.childstate.getKeys
• summary: Returns the keys with prefix from a child storage, leave empty to get all the keys

getKeysPaged(childKey: PrefixedStorageKey, prefix: StorageKey, count: u32, startKey?: StorageKey, at?: Hash): Vec<StorageKey>

• interface: api.rpc.childstate.getKeysPaged
• summary: Returns the keys with prefix from a child storage with pagination support

getStorage(childKey: PrefixedStorageKey, key: StorageKey, at?: Hash): Option<StorageData>

• interface: api.rpc.childstate.getStorage
• summary: Returns a child storage entry at a specific block state

getStorageEntries(childKey: PrefixedStorageKey, keys: Vec<StorageKey>, at?: Hash): Vec<Option<StorageData>>

• interface: api.rpc.childstate.getStorageEntries
• summary: Returns child storage entries for multiple keys at a specific block state

getStorageHash(childKey: PrefixedStorageKey, key: StorageKey, at?: Hash): Option<Hash>

• interface: api.rpc.childstate.getStorageHash
• summary: Returns the hash of a child storage entry at a block state

getStorageSize(childKey: PrefixedStorageKey, key: StorageKey, at?: Hash): Option<u64>

• interface: api.rpc.childstate.getStorageSize
• summary: Returns the size of a child storage entry at a block state

eth

accounts(): Vec<H160>

• interface: api.rpc.eth.accounts
• summary: Returns accounts list.

blockNumber(): U256

• interface: api.rpc.eth.blockNumber
• summary: Returns the blockNumber

call(request: EthCallRequest, number?: BlockNumber): Bytes

• interface: api.rpc.eth.call
• summary: Call contract, returning the output data.

chainId(): U64

• interface: api.rpc.eth.chainId
• summary: Returns the chain ID used for transaction signing at the current best block. None is returned if not available.

coinbase(): H160

• interface: api.rpc.eth.coinbase
• summary: Returns block author.

estimateGas(request: EthCallRequest, number?: BlockNumber): U256

• interface: api.rpc.eth.estimateGas
• summary: Estimate gas needed for execution of given contract.

feeHistory(blockCount: U256, newestBlock: BlockNumber, rewardPercentiles: Option<Vec<f64>>): EthFeeHistory

• interface: api.rpc.eth.feeHistory
• summary: Returns fee history for given block count & reward percentiles

gasPrice(): U256

• interface: api.rpc.eth.gasPrice
• summary: Returns current gas price.

getBalance(address: H160, number?: BlockNumber): U256

• interface: api.rpc.eth.getBalance
• summary: Returns balance of the given account.

getBlockByHash(hash: H256, full: bool): Option<EthRichBlock>

• interface: api.rpc.eth.getBlockByHash
• summary: Returns block with given hash.

getBlockByNumber(block: BlockNumber, full: bool): Option<EthRichBlock>

• interface: api.rpc.eth.getBlockByNumber
• summary: Returns block with given number.

getBlockTransactionCountByHash(hash: H256): U256

• interface: api.rpc.eth.getBlockTransactionCountByHash
• summary: Returns the number of transactions in a block with given hash.

getBlockTransactionCountByNumber(block: BlockNumber): U256

• interface: api.rpc.eth.getBlockTransactionCountByNumber
• summary: Returns the number of transactions in a block with given block number.

getCode(address: H160, number?: BlockNumber): Bytes

• interface: api.rpc.eth.getCode
• summary: Returns the code at given address at given time (block number).

getFilterChanges(index: U256): EthFilterChanges

• interface: api.rpc.eth.getFilterChanges
• summary: Returns filter changes since last poll.

getFilterLogs(index: U256): Vec<EthLog>

• interface: api.rpc.eth.getFilterLogs
• summary: Returns all logs matching given filter (in a range 'from' - 'to').

getLogs(filter: EthFilter): Vec<EthLog>

• interface: api.rpc.eth.getLogs
• summary: Returns logs matching given filter object.

getStorageAt(address: H160, index: U256, number?: BlockNumber): H256

• interface: api.rpc.eth.getStorageAt
• summary: Returns content of the storage at given address.

getTransactionByBlockHashAndIndex(hash: H256, index: U256): EthTransaction

• interface: api.rpc.eth.getTransactionByBlockHashAndIndex
• summary: Returns transaction at given block hash and index.

getTransactionByBlockNumberAndIndex(number: BlockNumber, index: U256): EthTransaction

• interface: api.rpc.eth.getTransactionByBlockNumberAndIndex
• summary: Returns transaction by given block number and index.

getTransactionByHash(hash: H256): EthTransaction

• interface: api.rpc.eth.getTransactionByHash
• summary: Get transaction by its hash.

getTransactionCount(address: H160, number?: BlockNumber): U256

• interface: api.rpc.eth.getTransactionCount
• summary: Returns the number of transactions sent from given address at given time (block number).

getTransactionReceipt(hash: H256): EthReceipt

• interface: api.rpc.eth.getTransactionReceipt
• summary: Returns transaction receipt by transaction hash.

getUncleByBlockHashAndIndex(hash: H256, index: U256): EthRichBlock

• interface: api.rpc.eth.getUncleByBlockHashAndIndex
• summary: Returns an uncles at given block and index.

getUncleByBlockNumberAndIndex(number: BlockNumber, index: U256): EthRichBlock

• interface: api.rpc.eth.getUncleByBlockNumberAndIndex
• summary: Returns an uncles at given block and index.

getUncleCountByBlockHash(hash: H256): U256

• interface: api.rpc.eth.getUncleCountByBlockHash
• summary: Returns the number of uncles in a block with given hash.

getUncleCountByBlockNumber(number: BlockNumber): U256

• interface: api.rpc.eth.getUncleCountByBlockNumber
• summary: Returns the number of uncles in a block with given block number.

getWork(): EthWork

• interface: api.rpc.eth.getWork
• summary: Returns the hash of the current block, the seedHash, and the boundary condition to be met.

hashrate(): U256

• interface: api.rpc.eth.hashrate
• summary: Returns the number of hashes per second that the node is mining with.

maxPriorityFeePerGas(): U256

• interface: api.rpc.eth.maxPriorityFeePerGas
• summary: Returns max priority fee per gas

mining(): bool

• interface: api.rpc.eth.mining
• summary: Returns true if client is actively mining new blocks.

newBlockFilter(): U256

• interface: api.rpc.eth.newBlockFilter
• summary: Returns id of new block filter.

newFilter(filter: EthFilter): U256

• interface: api.rpc.eth.newFilter
• summary: Returns id of new filter.

newPendingTransactionFilter(): U256

• interface: api.rpc.eth.newPendingTransactionFilter
• summary: Returns id of new block filter.

protocolVersion(): u64

• interface: api.rpc.eth.protocolVersion
• summary: Returns protocol version encoded as a string (quotes are necessary).

sendRawTransaction(bytes: Bytes): H256

• interface: api.rpc.eth.sendRawTransaction
• summary: Sends signed transaction, returning its hash.

submitHashrate(index: U256, hash: H256): bool

• interface: api.rpc.eth.submitHashrate
• summary: Used for submitting mining hashrate.

submitWork(nonce: H64, headerHash: H256, mixDigest: H256): bool

• interface: api.rpc.eth.submitWork
• summary: Used for submitting a proof-of-work solution.

subscribe(kind: EthSubKind, params?: EthSubParams): Null

• interface: api.rpc.eth.subscribe
• jsonrpc: subscription
• summary: Subscribe to Eth subscription.

syncing(): EthSyncStatus

• interface: api.rpc.eth.syncing
• summary: Returns an object with data about the sync status or false.

uninstallFilter(index: U256): bool

• interface: api.rpc.eth.uninstallFilter
• summary: Uninstalls filter.

net

listening(): bool

• interface: api.rpc.net.listening
• summary: Returns true if client is actively listening for network connections. Otherwise false.

peerCount(): Text

• interface: api.rpc.net.peerCount
• summary: Returns number of peers connected to node.

version(): Text

• interface: api.rpc.net.version
• summary: Returns protocol version.

payment

queryFeeDetails(extrinsic: Bytes, at?: BlockHash): FeeDetails

• interface: api.rpc.payment.queryFeeDetails
• summary: Query the detailed fee of a given encoded extrinsic

queryInfo(extrinsic: Bytes, at?: BlockHash): RuntimeDispatchInfoV1

• interface: api.rpc.payment.queryInfo
• summary: Retrieves the fee information for an encoded extrinsic

rpc

methods(): RpcMethods

• interface: api.rpc.rpc.methods
• summary: Retrieves the list of RPC methods that are exposed by the node

state

call(method: Text, data: Bytes, at?: BlockHash): Bytes

• interface: api.rpc.state.call
• summary: Perform a call to a builtin on the chain

getChildReadProof(childStorageKey: PrefixedStorageKey, keys: Vec<StorageKey>, at?: BlockHash): ReadProof

• interface: api.rpc.state.getChildReadProof
• summary: Returns proof of storage for child key entries at a specific block state.

getKeys(key: StorageKey, at?: BlockHash): Vec<StorageKey>

• interface: api.rpc.state.getKeys
• summary: Retrieves the keys with a certain prefix

getKeysPaged(key: StorageKey, count: u32, startKey?: StorageKey, at?: BlockHash): Vec<StorageKey>

• interface: api.rpc.state.getKeysPaged
• summary: Returns the keys with prefix with pagination support.

getMetadata(at?: BlockHash): Metadata

• interface: api.rpc.state.getMetadata
• summary: Returns the runtime metadata

getPairs(prefix: StorageKey, at?: BlockHash): Vec<KeyValue>

• interface: api.rpc.state.getPairs
• unsafe: this method is flagged as unsafe
• summary: Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)

getReadProof(keys: Vec<StorageKey>, at?: BlockHash): ReadProof

• interface: api.rpc.state.getReadProof
• summary: Returns proof of storage entries at a specific block state

getRuntimeVersion(at?: BlockHash): RuntimeVersion

• interface: api.rpc.state.getRuntimeVersion
• summary: Get the runtime version

getStorage(key: StorageKey, at?: BlockHash): StorageData

• interface: api.rpc.state.getStorage
• summary: Retrieves the storage for a key

getStorageHash(key: StorageKey, at?: BlockHash): Hash

• interface: api.rpc.state.getStorageHash
• summary: Retrieves the storage hash

getStorageSize(key: StorageKey, at?: BlockHash): u64

• interface: api.rpc.state.getStorageSize
• summary: Retrieves the storage size

queryStorage(keys: Vec<StorageKey>, fromBlock: Hash, toBlock?: BlockHash): Vec<StorageChangeSet>

• interface: api.rpc.state.queryStorage
• unsafe: this method is flagged as unsafe
• summary: Query historical storage entries (by key) starting from a start block

queryStorageAt(keys: Vec<StorageKey>, at?: BlockHash): Vec<StorageChangeSet>

• interface: api.rpc.state.queryStorageAt
• summary: Query storage entries (by key) starting at block hash given as the second parameter

subscribeRuntimeVersion(): RuntimeVersion

• interface: api.rpc.state.subscribeRuntimeVersion
• jsonrpc: subscription
• summary: Retrieves the runtime version via subscription

subscribeStorage(keys?: Vec<StorageKey>): StorageChangeSet

• interface: api.rpc.state.subscribeStorage
• jsonrpc: subscription
• summary: Subscribes to storage changes for the provided keys

system

accountNextIndex(accountId: AccountId): Index

• interface: api.rpc.system.accountNextIndex
• summary: Retrieves the next accountIndex as available on the node

chain(): Text

• interface: api.rpc.system.chain
• summary: Retrieves the chain

chainType(): ChainType

• interface: api.rpc.system.chainType
• summary: Retrieves the chain type

dryRun(extrinsic: Bytes, at?: BlockHash): ApplyExtrinsicResult

• interface: api.rpc.system.dryRun
• unsafe: this method is flagged as unsafe
• summary: Dry run an extrinsic at a given block

health(): Health

• interface: api.rpc.system.health
• summary: Return health status of the node

localListenAddresses(): Vec<Text>

• interface: api.rpc.system.localListenAddresses
• summary: 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

name(): Text

• interface: api.rpc.system.name
• summary: Retrieves the node name

nodeRoles(): Vec<NodeRole>

• interface: api.rpc.system.nodeRoles
• summary: Returns the roles the node is running as

peers(): Vec<PeerInfo>

• interface: api.rpc.system.peers
• unsafe: this method is flagged as unsafe
• summary: Returns the currently connected peers

properties(): ChainProperties

• interface: api.rpc.system.properties
• summary: Get a custom set of properties as a JSON object, defined in the chain spec

syncState(): SyncState

• interface: api.rpc.system.syncState
• summary: Returns the state of the syncing of the node

version(): Text

• interface: api.rpc.system.version
• summary: Retrieves the version of the node

web3

clientVersion(): Text

• interface: api.rpc.web3.clientVersion
• summary: Returns current client version.

sha3(data: Bytes): H256

• interface: api.rpc.web3.sha3
• summary: Returns sha3 of the given data