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
api.rpc.author.hasKey(publicKey: Bytes, keyType: Text): bool
JSON
{ "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
api.rpc.author.hasSessionKeys(sessionKeys: Bytes): bool
JSON
{ "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
api.rpc.author.insertKey(keyType: Text, suri: Text, publicKey: Bytes): Bytes
JSON
{ "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
api.rpc.author.pendingExtrinsics(): Vec<Extrinsic>
JSON
{ "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
api.rpc.author.removeExtrinsic(bytesOrHash: Vec<ExtrinsicOrHash>): Vec<Hash>
JSON
{ "id":1, "jsonrpc":"2.0", "method":"author_removeExtrinsic", "params":[bytesOrHash: Vec<ExtrinsicOrHash>] }

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<AuthorityId, EpochAuthorship>
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<StorageKey>
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<StorageKey>
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<StorageData>
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<StorageKey>, at?: Hash): Vec<Option<StorageData>>
JSON
{ "id":1, "jsonrpc":"2.0", "method":"childstate_getStorageEntries", "params":[childKey: PrefixedStorageKey, keys: Vec<StorageKey>, 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<Hash>
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<u64>
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<AssetId>): Json
JSON
{ "id":1, "jsonrpc":"2.0", "method":"dex_getAmountsIn", "params":[amountOut: u128, path: Vec<AssetId>] }

getAmountsOut

Given an array of AssetIds, return amounts out for an amount in Interface
api.rpc.dex.getAmountsOut(amountIn: u128, path: Vec<AssetId>): Json
JSON
{ "id":1, "jsonrpc":"2.0", "method":"dex_getAmountsOut", "params":[amountIn: u128, path: Vec<AssetId>] }

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<H160>
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<Vec<f64>>): EthFeeHistory
JSON
{ "id":1, "jsonrpc":"2.0", "method":"eth_feeHistory", "params":[blockCount: U256, newestBlock: BlockNumber, rewardPercentiles: Option<Vec<f64>>] }

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<EthRichBlock>
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<EthRichBlock>
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<EthLog>
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<EthLog>
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<EthEventProofResponse>
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<XrplEventProofResponse>
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<EncodedFinalityProofs>
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<Bytes>
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<StorageKey>, at?: BlockHash): ReadProof
JSON
{ "id":1, "jsonrpc":"2.0", "method":"state_getChildReadProof", "params":[childStorageKey: PrefixedStorageKey, keys: Vec<StorageKey>, at?: BlockHash] }

getKeys

Retrieves the keys with a certain prefix Interface
api.rpc.state.getKeys(key: StorageKey, at?: BlockHash): Vec<StorageKey>
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<StorageKey>
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<KeyValue>
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<StorageKey>, at?: BlockHash): ReadProof
JSON
{ "id":1, "jsonrpc":"2.0", "method":"state_getReadProof", "params":[keys: Vec<StorageKey>, 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<StorageKey>, fromBlock: Hash, toBlock?: BlockHash): Vec<StorageChangeSet>
JSON
{ "id":1, "jsonrpc":"2.0", "method":"state_queryStorage", "params":[keys: Vec<StorageKey>, 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<StorageKey>, at?: BlockHash): Vec<StorageChangeSet>
JSON
{ "id":1, "jsonrpc":"2.0", "method":"state_queryStorageAt", "params":[keys: Vec<StorageKey>, 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<StorageKey>): StorageChangeSet
JSON
{ "id":1, "jsonrpc":"2.0", "method":"state_subscribeStorage", "params":[keys?: Vec<StorageKey>] }

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<Text>, storageKeys: Option<Text>, methods: Option<Text>): TraceBlockResponse
JSON
{ "id":1, "jsonrpc":"2.0", "method":"state_traceBlock", "params":[block: Hash, targets: Option<Text>, storageKeys: Option<Text>, methods: Option<Text>] }

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<Text>
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<NodeRole>
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<PeerInfo>
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<Text>
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<String>)>,
}

type GetPermissionsResult {
	permissions: Vec<(String, Vec<DataPermission>)>,
	permission_reference: Option<PermissionReferenceRecord>,
}

api.rpc.syloDataPermissions.getPermissions(
  dataAuthor: AccountId,
  grantee: AccountId,
  dataIds: Vec<String>
): GetPermissionsResult
JSON
{ "id":1, "jsonrpc":"2.0", "method":"syloDataPermissions_getPermissions", "params":[dataAuthor: AccountId, grantee: AccountId, dataIds: Vec<String>] }