JSON-RPC
The following sections contain known RPC methods that may be available on specific nodes (depending on configuration and available pallets) and allow you to interact with the actual node, query, and submit.
#
authorBytes
, keyType: Text
): bool
#
hasKey(publicKey: - interface:
api.rpc.author.hasKey
- jsonrpc:
author_hasKey
- summary: Returns true if the keystore has private keys for the given public key and key type.
Bytes
): bool
#
hasSessionKeys(sessionKeys: - interface:
api.rpc.author.hasSessionKeys
- jsonrpc:
author_hasSessionKeys
- summary: Returns true if the keystore has private keys for the given session public keys.
Text
, suri: Text
, publicKey: Bytes
): Bytes
#
insertKey(keyType: - interface:
api.rpc.author.insertKey
- jsonrpc:
author_insertKey
- summary: Insert a key into the keystore.
Vec<Extrinsic>
#
pendingExtrinsics(): - interface:
api.rpc.author.pendingExtrinsics
- jsonrpc:
author_pendingExtrinsics
- summary: Returns all pending extrinsics, potentially grouped by sender
Vec<ExtrinsicOrHash>
): Vec<Hash>
#
removeExtrinsic(bytesOrHash: - interface:
api.rpc.author.removeExtrinsic
- jsonrpc:
author_removeExtrinsic
- summary: Remove given extrinsic from the pool and temporarily ban it to prevent reimporting
Bytes
#
rotateKeys(): - interface:
api.rpc.author.rotateKeys
- jsonrpc:
author_rotateKeys
- summary: Generate new session keys and returns the corresponding public keys
Extrinsic
): ExtrinsicStatus
#
submitAndWatchExtrinsic(extrinsic: - interface:
api.rpc.author.submitAndWatchExtrinsic
- jsonrpc:
author_submitAndWatchExtrinsic
- summary: Submit and subscribe to watch an extrinsic until unsubscribed
Extrinsic
): Hash
#
submitExtrinsic(extrinsic: - interface:
api.rpc.author.submitExtrinsic
- jsonrpc:
author_submitExtrinsic
- summary: Submit a fully formatted extrinsic for block inclusion
#
babeHashMap<AuthorityId, EpochAuthorship>
#
epochAuthorship(): - interface:
api.rpc.babe.epochAuthorship
- jsonrpc:
babe_epochAuthorship
- summary: Returns data about which slots (primary or secondary) can be claimed in the current epoch with the keys in the keystore
#
beefyH256
#
getFinalizedHead(): - interface:
api.rpc.beefy.getFinalizedHead
- jsonrpc:
beefy_getFinalizedHead
- summary: Returns hash of the latest BEEFY finalized block as seen by this client.
BeefySignedCommitment
#
subscribeJustifications(): - interface:
api.rpc.beefy.subscribeJustifications
- jsonrpc:
beefy_subscribeJustifications
- summary: Returns the block most recently finalized by BEEFY, alongside side its justification.
#
chainBlockHash
): SignedBlock
#
getBlock(hash?: - interface:
api.rpc.chain.getBlock
- jsonrpc:
chain_getBlock
- summary: Get header and body of a relay chain block
BlockNumber
): BlockHash
#
getBlockHash(blockNumber?: - interface:
api.rpc.chain.getBlockHash
- jsonrpc:
chain_getBlockHash
- summary: Get the block hash for a specific block
BlockHash
#
getFinalizedHead(): - interface:
api.rpc.chain.getFinalizedHead
- jsonrpc:
chain_getFinalizedHead
- summary: Get hash of the last finalized block in the canon chain
BlockHash
): Header
#
getHeader(hash?: - interface:
api.rpc.chain.getHeader
- jsonrpc:
chain_getHeader
- summary: Retrieves the header for a specific block
Header
#
subscribeAllHeads(): - interface:
api.rpc.chain.subscribeAllHeads
- jsonrpc:
chain_subscribeAllHeads
- summary: Retrieves the newest header via subscription
Header
#
subscribeFinalizedHeads(): - interface:
api.rpc.chain.subscribeFinalizedHeads
- jsonrpc:
chain_subscribeFinalizedHeads
- summary: Retrieves the best finalized header via subscription
Header
#
subscribeNewHeads(): - interface:
api.rpc.chain.subscribeNewHeads
- jsonrpc:
chain_subscribeNewHeads
- summary: Retrieves the best header via subscription
#
childstatePrefixedStorageKey
, prefix: StorageKey
, at?: Hash
): Vec<StorageKey>
#
getKeys(childKey: - interface:
api.rpc.childstate.getKeys
- jsonrpc:
childstate_getKeys
- summary: Returns the keys with prefix from a child storage, leave empty to get all the keys
PrefixedStorageKey
, prefix: StorageKey
, count: u32
, startKey?: StorageKey
, at?: Hash
): Vec<StorageKey>
#
getKeysPaged(childKey: - interface:
api.rpc.childstate.getKeysPaged
- jsonrpc:
childstate_getKeysPaged
- summary: Returns the keys with prefix from a child storage with pagination support
PrefixedStorageKey
, key: StorageKey
, at?: Hash
): Option<StorageData>
#
getStorage(childKey: - interface:
api.rpc.childstate.getStorage
- jsonrpc:
childstate_getStorage
- summary: Returns a child storage entry at a specific block state
PrefixedStorageKey
, keys: Vec<StorageKey>
, at?: Hash
): Vec<Option<StorageData>>
#
getStorageEntries(childKey: - interface:
api.rpc.childstate.getStorageEntries
- jsonrpc:
childstate_getStorageEntries
- summary: Returns child storage entries for multiple keys at a specific block state
PrefixedStorageKey
, key: StorageKey
, at?: Hash
): Option<Hash>
#
getStorageHash(childKey: - interface:
api.rpc.childstate.getStorageHash
- jsonrpc:
childstate_getStorageHash
- summary: Returns the hash of a child storage entry at a block state
PrefixedStorageKey
, key: StorageKey
, at?: Hash
): Option<u64>
#
getStorageSize(childKey: - interface:
api.rpc.childstate.getStorageSize
- jsonrpc:
childstate_getStorageSize
- summary: Returns the size of a child storage entry at a block state
#
contractsContractCallRequest
, at?: BlockHash
): ContractExecResult
#
call(callRequest: - interface:
api.rpc.contracts.call
- jsonrpc:
contracts_call
- summary: Executes a call to a contract
AccountId
, key: H256
, at?: BlockHash
): Option<Bytes>
#
getStorage(address: - interface:
api.rpc.contracts.getStorage
- jsonrpc:
contracts_getStorage
- summary: Returns the value under a specified storage key in a contract
InstantiateRequest
, at?: BlockHash
): ContractInstantiateResult
#
instantiate(request: - interface:
api.rpc.contracts.instantiate
- jsonrpc:
contracts_instantiate
- summary: Instantiate a new contract
AccountId
, at?: BlockHash
): Option<BlockNumber>
#
rentProjection(address: - interface:
api.rpc.contracts.rentProjection
- jsonrpc:
contracts_rentProjection
- summary: Returns the projected time a given contract will be able to sustain paying its rent
CodeUploadRequest
, at?: BlockHash
): CodeUploadResult
#
uploadCode(uploadRequest: - interface:
api.rpc.contracts.uploadCode
- jsonrpc:
contracts_upload_code
- summary: Upload new code without instantiating a contract from it
#
devHash
): Option<BlockStats>
#
getBlockStats(at: - interface:
api.rpc.dev.getBlockStats
- jsonrpc:
dev_getBlockStats
- summary: Reexecute the specified
block_hash
and gather statistics while doing so
#
enginebool
, finalize: bool
, parentHash?: BlockHash
): CreatedBlock
#
createBlock(createEmpty: - interface:
api.rpc.engine.createBlock
- jsonrpc:
engine_createBlock
- summary: Instructs the manual-seal authorship task to create a new block
BlockHash
, justification?: Justification
): bool
#
finalizeBlock(hash: - interface:
api.rpc.engine.finalizeBlock
- jsonrpc:
engine_finalizeBlock
- summary: Instructs the manual-seal authorship task to finalize a block
#
ethVec<H160>
#
accounts(): - interface:
api.rpc.eth.accounts
- jsonrpc:
eth_accounts
- summary: Returns accounts list.
U256
#
blockNumber(): - interface:
api.rpc.eth.blockNumber
- jsonrpc:
eth_blockNumber
- summary: Returns the blockNumber
EthCallRequest
, number?: BlockNumber
): Bytes
#
call(request: - interface:
api.rpc.eth.call
- jsonrpc:
eth_call
- summary: Call contract, returning the output data.
U64
#
chainId(): - interface:
api.rpc.eth.chainId
- jsonrpc:
eth_chainId
- summary: Returns the chain ID used for transaction signing at the current best block. None is returned if not available.
H160
#
coinbase(): - interface:
api.rpc.eth.coinbase
- jsonrpc:
eth_coinbase
- summary: Returns block author.
EthCallRequest
, number?: BlockNumber
): U256
#
estimateGas(request: - interface:
api.rpc.eth.estimateGas
- jsonrpc:
eth_estimateGas
- summary: Estimate gas needed for execution of given contract.
U256
, newestBlock: BlockNumber
, rewardPercentiles: Option<Vec<f64>>
): EthFeeHistory
#
feeHistory(blockCount: - interface:
api.rpc.eth.feeHistory
- jsonrpc:
eth_feeHistory
- summary: Returns fee history for given block count & reward percentiles
U256
#
gasPrice(): - interface:
api.rpc.eth.gasPrice
- jsonrpc:
eth_gasPrice
- summary: Returns current gas price.
H160
, number?: BlockNumber
): U256
#
getBalance(address: - interface:
api.rpc.eth.getBalance
- jsonrpc:
eth_getBalance
- summary: Returns balance of the given account.
H256
, full: bool
): Option<EthRichBlock>
#
getBlockByHash(hash: - interface:
api.rpc.eth.getBlockByHash
- jsonrpc:
eth_getBlockByHash
- summary: Returns block with given hash.
BlockNumber
, full: bool
): Option<EthRichBlock>
#
getBlockByNumber(block: - interface:
api.rpc.eth.getBlockByNumber
- jsonrpc:
eth_getBlockByNumber
- summary: Returns block with given number.
H256
): U256
#
getBlockTransactionCountByHash(hash: - interface:
api.rpc.eth.getBlockTransactionCountByHash
- jsonrpc:
eth_getBlockTransactionCountByHash
- summary: Returns the number of transactions in a block with given hash.
BlockNumber
): U256
#
getBlockTransactionCountByNumber(block: - interface:
api.rpc.eth.getBlockTransactionCountByNumber
- jsonrpc:
eth_getBlockTransactionCountByNumber
- summary: Returns the number of transactions in a block with given block number.
H160
, number?: BlockNumber
): Bytes
#
getCode(address: - interface:
api.rpc.eth.getCode
- jsonrpc:
eth_getCode
- summary: Returns the code at given address at given time (block number).
U256
): EthFilterChanges
#
getFilterChanges(index: - interface:
api.rpc.eth.getFilterChanges
- jsonrpc:
eth_getFilterChanges
- summary: Returns filter changes since last poll.
U256
): Vec<EthLog>
#
getFilterLogs(index: - interface:
api.rpc.eth.getFilterLogs
- jsonrpc:
eth_getFilterLogs
- summary: Returns all logs matching given filter (in a range 'from' - 'to').
EthFilter
): Vec<EthLog>
#
getLogs(filter: - interface:
api.rpc.eth.getLogs
- jsonrpc:
eth_getLogs
- summary: Returns logs matching given filter object.
H160
, storageKeys: Vec<H256>
, number: BlockNumber
): EthAccount
#
getProof(address: - interface:
api.rpc.eth.getProof
- jsonrpc:
eth_getProof
- summary: Returns proof for account and storage.
H160
, index: U256
, number?: BlockNumber
): H256
#
getStorageAt(address: - interface:
api.rpc.eth.getStorageAt
- jsonrpc:
eth_getStorageAt
- summary: Returns content of the storage at given address.
H256
, index: U256
): EthTransaction
#
getTransactionByBlockHashAndIndex(hash: - interface:
api.rpc.eth.getTransactionByBlockHashAndIndex
- jsonrpc:
eth_getTransactionByBlockHashAndIndex
- summary: Returns transaction at given block hash and index.
BlockNumber
, index: U256
): EthTransaction
#
getTransactionByBlockNumberAndIndex(number: - interface:
api.rpc.eth.getTransactionByBlockNumberAndIndex
- jsonrpc:
eth_getTransactionByBlockNumberAndIndex
- summary: Returns transaction by given block number and index.
H256
): EthTransaction
#
getTransactionByHash(hash: - interface:
api.rpc.eth.getTransactionByHash
- jsonrpc:
eth_getTransactionByHash
- summary: Get transaction by its hash.
H256
, number?: BlockNumber
): U256
#
getTransactionCount(hash: - interface:
api.rpc.eth.getTransactionCount
- jsonrpc:
eth_getTransactionCount
- summary: Returns the number of transactions sent from given address at given time (block number).
H256
): EthReceipt
#
getTransactionReceipt(hash: - interface:
api.rpc.eth.getTransactionReceipt
- jsonrpc:
eth_getTransactionReceipt
- summary: Returns transaction receipt by transaction hash.
H256
, index: U256
): EthRichBlock
#
getUncleByBlockHashAndIndex(hash: - interface:
api.rpc.eth.getUncleByBlockHashAndIndex
- jsonrpc:
eth_getUncleByBlockHashAndIndex
- summary: Returns an uncles at given block and index.
BlockNumber
, index: U256
): EthRichBlock
#
getUncleByBlockNumberAndIndex(number: - interface:
api.rpc.eth.getUncleByBlockNumberAndIndex
- jsonrpc:
eth_getUncleByBlockNumberAndIndex
- summary: Returns an uncles at given block and index.
H256
): U256
#
getUncleCountByBlockHash(hash: - interface:
api.rpc.eth.getUncleCountByBlockHash
- jsonrpc:
eth_getUncleCountByBlockHash
- summary: Returns the number of uncles in a block with given hash.
BlockNumber
): U256
#
getUncleCountByBlockNumber(number: - interface:
api.rpc.eth.getUncleCountByBlockNumber
- jsonrpc:
eth_getUncleCountByBlockNumber
- summary: Returns the number of uncles in a block with given block number.
EthWork
#
getWork(): - interface:
api.rpc.eth.getWork
- jsonrpc:
eth_getWork
- summary: Returns the hash of the current block, the seedHash, and the boundary condition to be met.
U256
#
hashrate(): - interface:
api.rpc.eth.hashrate
- jsonrpc:
eth_hashrate
- summary: Returns the number of hashes per second that the node is mining with.
U256
#
maxPriorityFeePerGas(): - interface:
api.rpc.eth.maxPriorityFeePerGas
- jsonrpc:
eth_maxPriorityFeePerGas
- summary: Returns max priority fee per gas
bool
#
mining(): - interface:
api.rpc.eth.mining
- jsonrpc:
eth_mining
- summary: Returns true if client is actively mining new blocks.
U256
#
newBlockFilter(): - interface:
api.rpc.eth.newBlockFilter
- jsonrpc:
eth_newBlockFilter
- summary: Returns id of new block filter.
EthFilter
): U256
#
newFilter(filter: - interface:
api.rpc.eth.newFilter
- jsonrpc:
eth_newFilter
- summary: Returns id of new filter.
U256
#
newPendingTransactionFilter(): - interface:
api.rpc.eth.newPendingTransactionFilter
- jsonrpc:
eth_newPendingTransactionFilter
- summary: Returns id of new block filter.
u64
#
protocolVersion(): - interface:
api.rpc.eth.protocolVersion
- jsonrpc:
eth_protocolVersion
- summary: Returns protocol version encoded as a string (quotes are necessary).
Bytes
): H256
#
sendRawTransaction(bytes: - interface:
api.rpc.eth.sendRawTransaction
- jsonrpc:
eth_sendRawTransaction
- summary: Sends signed transaction, returning its hash.
EthTransactionRequest
): H256
#
sendTransaction(tx: - interface:
api.rpc.eth.sendTransaction
- jsonrpc:
eth_sendTransaction
- summary: Sends transaction; will block waiting for signer to return the transaction hash
U256
, hash: H256
): bool
#
submitHashrate(index: - interface:
api.rpc.eth.submitHashrate
- jsonrpc:
eth_submitHashrate
- summary: Used for submitting mining hashrate.
H64
, headerHash: H256
, mixDigest: H256
): bool
#
submitWork(nonce: - interface:
api.rpc.eth.submitWork
- jsonrpc:
eth_submitWork
- summary: Used for submitting a proof-of-work solution.
EthSubKind
, params?: EthSubParams
): Null
#
subscribe(kind: - interface:
api.rpc.eth.subscribe
- jsonrpc:
eth_subscribe
- summary: Subscribe to Eth subscription.
EthSyncStatus
#
syncing(): - interface:
api.rpc.eth.syncing
- jsonrpc:
eth_syncing
- summary: Returns an object with data about the sync status or false.
U256
): bool
#
uninstallFilter(index: - interface:
api.rpc.eth.uninstallFilter
- jsonrpc:
eth_uninstallFilter
- summary: Uninstalls filter.
#
eth/netbool
#
listening(): - interface:
api.rpc.net.listening
- jsonrpc:
net_listening
- summary: Returns true if client is actively listening for network connections. Otherwise false.
String
#
peerCount(): - interface:
api.rpc.net.peerCount
- jsonrpc:
net_peerCount
- summary: Returns number of peers connected to node.
String
#
version(): - interface:
api.rpc.net.version
- jsonrpc:
net_version
- summary: Returns protocol version.
#
eth/web3String
#
clientVersion(): - interface:
api.rpc.web3.clientVersion
- jsonrpc:
web3_clientVersion
- summary: Returns current client version.
Bytes
): H256
#
sha3(data: - interface:
api.rpc.web3.sha3
- jsonrpc:
web3_sha3
- summary: Returns sha3 of the given data
#
grandpaBlockNumber
): Option<EncodedFinalityProofs>
#
proveFinality(blockNumber: - interface:
api.rpc.grandpa.proveFinality
- jsonrpc:
grandpa_proveFinality
- summary: Prove finality for the given block number, returning the Justification for the last block in the set.
ReportedRoundStates
#
roundState(): - interface:
api.rpc.grandpa.roundState
- jsonrpc:
grandpa_roundState
- summary: Returns the state of the current best round state as well as the ongoing background rounds
JustificationNotification
#
subscribeJustifications(): - interface:
api.rpc.grandpa.subscribeJustifications
- jsonrpc:
grandpa_subscribeJustifications
- summary: Subscribes to grandpa justifications
#
mmrVec<u64>
, at?: BlockHash
): MmrLeafProof
#
generateBatchProof(leafIndices: - interface:
api.rpc.mmr.generateBatchProof
- jsonrpc:
mmr_generateBatchProof
- summary: Generate MMR proof for the given leaf indices.
u64
, at?: BlockHash
): MmrLeafBatchProof
#
generateProof(leafIndex: - interface:
api.rpc.mmr.generateProof
- jsonrpc:
mmr_generateProof
- summary: Generate MMR proof for given leaf index.
#
offchainStorageKind
, key: Bytes
): Option<Bytes>
#
localStorageGet(kind: - interface:
api.rpc.offchain.localStorageGet
- jsonrpc:
offchain_localStorageGet
- summary: Get offchain local storage under given key and prefix
StorageKind
, key: Bytes
, value: Bytes
): Null
#
localStorageSet(kind: - interface:
api.rpc.offchain.localStorageSet
- jsonrpc:
offchain_localStorageSet
- summary: Set offchain local storage under given key and prefix
#
paymentBytes
, at?: BlockHash
): FeeDetails
#
queryFeeDetails(extrinsic: - interface:
api.rpc.payment.queryFeeDetails
- jsonrpc:
payment_queryFeeDetails
- summary: Query the detailed fee of a given encoded extrinsic
Bytes
, at?: BlockHash
): RuntimeDispatchInfo
#
queryInfo(extrinsic: - interface:
api.rpc.payment.queryInfo
- jsonrpc:
payment_queryInfo
- summary: Retrieves the fee information for an encoded extrinsic
#
rpcRpcMethods
#
methods(): - interface:
api.rpc.rpc.methods
- jsonrpc:
rpc_methods
- summary: Retrieves the list of RPC methods that are exposed by the node
#
stateText
, data: Bytes
, at?: BlockHash
): Bytes
#
call(method: - interface:
api.rpc.state.call
- jsonrpc:
state_call
- summary: Perform a call to a builtin on the chain
StorageKey
, childDefinition: StorageKey
, childType: u32
, key: StorageKey
, at?: BlockHash
): Vec<StorageKey>
#
getChildKeys(childStorageKey: - interface:
api.rpc.state.getChildKeys
- jsonrpc:
state_getChildKeys
- summary: Retrieves the keys with prefix of a specific child storage
PrefixedStorageKey
, keys: Vec<StorageKey>
, at?: BlockHash
): ReadProof
#
getChildReadProof(childStorageKey: - interface:
api.rpc.state.getChildReadProof
- jsonrpc:
state_getChildReadProof
- summary: Returns proof of storage for child key entries at a specific block state.
StorageKey
, childDefinition: StorageKey
, childType: u32
, key: StorageKey
, at?: BlockHash
): StorageData
#
getChildStorage(childStorageKey: - interface:
api.rpc.state.getChildStorage
- jsonrpc:
state_getChildStorage
- summary: Retrieves the child storage for a key
StorageKey
, childDefinition: StorageKey
, childType: u32
, key: StorageKey
, at?: BlockHash
): Hash
#
getChildStorageHash(childStorageKey: - interface:
api.rpc.state.getChildStorageHash
- jsonrpc:
state_getChildStorageHash
- summary: Retrieves the child storage hash
StorageKey
, childDefinition: StorageKey
, childType: u32
, key: StorageKey
, at?: BlockHash
): u64
#
getChildStorageSize(childStorageKey: - interface:
api.rpc.state.getChildStorageSize
- jsonrpc:
state_getChildStorageSize
- summary: Retrieves the child storage size
StorageKey
, at?: BlockHash
): Vec<StorageKey>
#
getKeys(key: - interface:
api.rpc.state.getKeys
- jsonrpc:
state_getKeys
- summary: Retrieves the keys with a certain prefix
StorageKey
, count: u32
, startKey?: StorageKey
, at?: BlockHash
): Vec<StorageKey>
#
getKeysPaged(key: - interface:
api.rpc.state.getKeysPaged
- jsonrpc:
state_getKeysPaged
- summary: Returns the keys with prefix with pagination support.
BlockHash
): Metadata
#
getMetadata(at?: - interface:
api.rpc.state.getMetadata
- jsonrpc:
state_getMetadata
- summary: Returns the runtime metadata
StorageKey
, at?: BlockHash
): Vec<KeyValue>
#
getPairs(prefix: - interface:
api.rpc.state.getPairs
- jsonrpc:
state_getPairs
- summary: Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)
Vec<StorageKey>
, at?: BlockHash
): ReadProof
#
getReadProof(keys: - interface:
api.rpc.state.getReadProof
- jsonrpc:
state_getReadProof
- summary: Returns proof of storage entries at a specific block state
BlockHash
): RuntimeVersion
#
getRuntimeVersion(at?: - interface:
api.rpc.state.getRuntimeVersion
- jsonrpc:
state_getRuntimeVersion
- summary: Get the runtime version
StorageKey
, at?: BlockHash
): StorageData
#
getStorage(key: - interface:
api.rpc.state.getStorage
- jsonrpc:
state_getStorage
- summary: Retrieves the storage for a key
StorageKey
, at?: BlockHash
): Hash
#
getStorageHash(key: - interface:
api.rpc.state.getStorageHash
- jsonrpc:
state_getStorageHash
- summary: Retrieves the storage hash
StorageKey
, at?: BlockHash
): u64
#
getStorageSize(key: - interface:
api.rpc.state.getStorageSize
- jsonrpc:
state_getStorageSize
- summary: Retrieves the storage size
Vec<StorageKey>
, fromBlock: Hash
, toBlock?: BlockHash
): Vec<StorageChangeSet>
#
queryStorage(keys: - interface:
api.rpc.state.queryStorage
- jsonrpc:
state_queryStorage
- summary: Query historical storage entries (by key) starting from a start block
Vec<StorageKey>
, at?: BlockHash
): Vec<StorageChangeSet>
#
queryStorageAt(keys: - interface:
api.rpc.state.queryStorageAt
- jsonrpc:
state_queryStorageAt
- summary: Query storage entries (by key) starting at block hash given as the second parameter
RuntimeVersion
#
subscribeRuntimeVersion(): - interface:
api.rpc.state.subscribeRuntimeVersion
- jsonrpc:
state_subscribeRuntimeVersion
- summary: Retrieves the runtime version via subscription
Vec<StorageKey>
): StorageChangeSet
#
subscribeStorage(keys?: - interface:
api.rpc.state.subscribeStorage
- jsonrpc:
state_subscribeStorage
- summary: Subscribes to storage changes for the provided keys
Hash
, targets: Option<Text>
, storageKeys: Option<Text>
, methods: Option<Text>
): TraceBlockResponse
#
traceBlock(block: - interface:
api.rpc.state.traceBlock
- jsonrpc:
state_traceBlock
- summary: Provides a way to trace the re-execution of a single block
BlockHash
): MigrationStatusResult
#
trieMigrationStatus(at?: - interface:
api.rpc.state.trieMigrationStatus
- jsonrpc:
state_trieMigrationStatus
- summary: Check current migration state
#
syncstatebool
): Json
#
genSyncSpec(raw: - interface:
api.rpc.syncstate.genSyncSpec
- jsonrpc:
sync_state_genSyncSpec
- summary: Returns the json-serialized chainspec running the node, with a sync state.
#
systemAccountId
): Index
#
accountNextIndex(accountId: - interface:
api.rpc.system.accountNextIndex
- jsonrpc:
system_accountNextIndex
- summary: Retrieves the next accountIndex as available on the node
Text
): Null
#
addLogFilter(directives: - interface:
api.rpc.system.addLogFilter
- jsonrpc:
system_addLogFilter
- summary: Adds the supplied directives to the current log filter
Text
): Text
#
addReservedPeer(peer: - interface:
api.rpc.system.addReservedPeer
- jsonrpc:
system_addReservedPeer
- summary: Adds a reserved peer
Text
#
chain(): - interface:
api.rpc.system.chain
- jsonrpc:
system_chain
- summary: Retrieves the chain
ChainType
#
chainType(): - interface:
api.rpc.system.chainType
- jsonrpc:
system_chainType
- summary: Retrieves the chain type
Bytes
, at?: BlockHash
): ApplyExtrinsicResult
#
dryRun(extrinsic: - interface:
api.rpc.system.dryRun
- jsonrpc:
system_dryRun
- summary: Dry run an extrinsic at a given block
Health
#
health(): - interface:
api.rpc.system.health
- jsonrpc:
system_health
- summary: Return health status of the node
Vec<Text>
#
localListenAddresses(): - interface:
api.rpc.system.localListenAddresses
- jsonrpc:
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
Text
#
localPeerId(): - interface:
api.rpc.system.localPeerId
- jsonrpc:
system_localPeerId
- summary: Returns the base58-encoded PeerId of the node
Text
#
name(): - interface:
api.rpc.system.name
- jsonrpc:
system_name
- summary: Retrieves the node name
NetworkState
#
networkState(): - interface:
api.rpc.system.networkState
- jsonrpc:
system_networkState
- summary: Returns current state of the network
Vec<NodeRole>
#
nodeRoles(): - interface:
api.rpc.system.nodeRoles
- jsonrpc:
system_nodeRoles
- summary: Returns the roles the node is running as
Vec<PeerInfo>
#
peers(): - interface:
api.rpc.system.peers
- jsonrpc:
system_peers
- summary: Returns the currently connected peers
ChainProperties
#
properties(): - interface:
api.rpc.system.properties
- jsonrpc:
system_properties
- summary: Get a custom set of properties as a JSON object, defined in the chain spec
Text
): Text
#
removeReservedPeer(peerId: - interface:
api.rpc.system.removeReservedPeer
- jsonrpc:
system_removeReservedPeer
- summary: Remove a reserved peer
Vec<Text>
#
reservedPeers(): - interface:
api.rpc.system.reservedPeers
- jsonrpc:
system_reservedPeers
- summary: Returns the list of reserved peers
Null
#
resetLogFilter(): - interface:
api.rpc.system.resetLogFilter
- jsonrpc:
system_resetLogFilter
- summary: Resets the log filter to Substrate defaults
SyncState
#
syncState(): - interface:
api.rpc.system.syncState
- jsonrpc:
system_syncState
- summary: Returns the state of the syncing of the node
Text
#
version(): - interface:
api.rpc.system.version
- jsonrpc:
system_version
- summary: Retrieves the version of the node