git.delta.rocks / unique-network / refs/commits / d0d6ce422c83

1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/rpc-core/types/jsonrpc';78import type { PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCollectionLimits, UpDataStructsCollectionStats, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, UpDataStructsRpcCollection, UpDataStructsTokenChild, UpDataStructsTokenData, UpPovEstimateRpcPovInfo } from './default';9import type { AugmentedRpc } from '@polkadot/rpc-core/types';10import type { Metadata, StorageKey } from '@polkadot/types';11import type { Bytes, HashMap, Json, Null, Option, Text, U256, U64, Vec, bool, f64, u128, u32, u64 } from '@polkadot/types-codec';12import type { AnyNumber, Codec, ITuple } from '@polkadot/types-codec/types';13import type { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author';14import type { EpochAuthorship } from '@polkadot/types/interfaces/babe';15import type { BeefySignedCommitment } from '@polkadot/types/interfaces/beefy';16import type { BlockHash } from '@polkadot/types/interfaces/chain';17import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';18import type { AuthorityId } from '@polkadot/types/interfaces/consensus';19import type { CodeUploadRequest, CodeUploadResult, ContractCallRequest, ContractExecResult, ContractInstantiateResult, InstantiateRequestV1 } from '@polkadot/types/interfaces/contracts';20import type { BlockStats } from '@polkadot/types/interfaces/dev';21import type { CreatedBlock } from '@polkadot/types/interfaces/engine';22import type { EthAccount, EthCallRequest, EthFeeHistory, EthFilter, EthFilterChanges, EthLog, EthReceipt, EthRichBlock, EthSubKind, EthSubParams, EthSyncStatus, EthTransaction, EthTransactionRequest, EthWork } from '@polkadot/types/interfaces/eth';23import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';24import type { EncodedFinalityProofs, JustificationNotification, ReportedRoundStates } from '@polkadot/types/interfaces/grandpa';25import type { MmrHash, MmrLeafBatchProof } from '@polkadot/types/interfaces/mmr';26import type { StorageKind } from '@polkadot/types/interfaces/offchain';27import type { FeeDetails, RuntimeDispatchInfoV1 } from '@polkadot/types/interfaces/payment';28import type { RpcMethods } from '@polkadot/types/interfaces/rpc';29import type { AccountId, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';30import type { MigrationStatusResult, ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state';31import type { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo, SyncState } from '@polkadot/types/interfaces/system';32import type { IExtrinsic, Observable } from '@polkadot/types/types';3334export type __AugmentedRpc = AugmentedRpc<() => unknown>;3536declare module '@polkadot/rpc-core/types/jsonrpc' {37  interface RpcInterface {38    appPromotion: {39      /**40       * Returns the total amount of unstaked tokens41       **/42      pendingUnstake: AugmentedRpc<(staker?: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u128>>;43      /**44       * Returns the total amount of unstaked tokens per block45       **/46      pendingUnstakePerBlock: AugmentedRpc<(staker: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<ITuple<[u32, u128]>>>>;47      /**48       * Returns the total amount of staked tokens49       **/50      totalStaked: AugmentedRpc<(staker?: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u128>>;51      /**52       * Returns the total amount of staked tokens per block when staked53       **/54      totalStakedPerBlock: AugmentedRpc<(staker: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<ITuple<[u32, u128]>>>>;55    };56    author: {57      /**58       * Returns true if the keystore has private keys for the given public key and key type.59       **/60      hasKey: AugmentedRpc<(publicKey: Bytes | string | Uint8Array, keyType: Text | string) => Observable<bool>>;61      /**62       * Returns true if the keystore has private keys for the given session public keys.63       **/64      hasSessionKeys: AugmentedRpc<(sessionKeys: Bytes | string | Uint8Array) => Observable<bool>>;65      /**66       * Insert a key into the keystore.67       **/68      insertKey: AugmentedRpc<(keyType: Text | string, suri: Text | string, publicKey: Bytes | string | Uint8Array) => Observable<Bytes>>;69      /**70       * Returns all pending extrinsics, potentially grouped by sender71       **/72      pendingExtrinsics: AugmentedRpc<() => Observable<Vec<Extrinsic>>>;73      /**74       * Remove given extrinsic from the pool and temporarily ban it to prevent reimporting75       **/76      removeExtrinsic: AugmentedRpc<(bytesOrHash: Vec<ExtrinsicOrHash> | (ExtrinsicOrHash | { Hash: any } | { Extrinsic: any } | string | Uint8Array)[]) => Observable<Vec<Hash>>>;77      /**78       * Generate new session keys and returns the corresponding public keys79       **/80      rotateKeys: AugmentedRpc<() => Observable<Bytes>>;81      /**82       * Submit and subscribe to watch an extrinsic until unsubscribed83       **/84      submitAndWatchExtrinsic: AugmentedRpc<(extrinsic: Extrinsic | IExtrinsic | string | Uint8Array) => Observable<ExtrinsicStatus>>;85      /**86       * Submit a fully formatted extrinsic for block inclusion87       **/88      submitExtrinsic: AugmentedRpc<(extrinsic: Extrinsic | IExtrinsic | string | Uint8Array) => Observable<Hash>>;89    };90    babe: {91      /**92       * Returns data about which slots (primary or secondary) can be claimed in the current epoch with the keys in the keystore93       **/94      epochAuthorship: AugmentedRpc<() => Observable<HashMap<AuthorityId, EpochAuthorship>>>;95    };96    beefy: {97      /**98       * Returns hash of the latest BEEFY finalized block as seen by this client.99       **/100      getFinalizedHead: AugmentedRpc<() => Observable<H256>>;101      /**102       * Returns the block most recently finalized by BEEFY, alongside side its justification.103       **/104      subscribeJustifications: AugmentedRpc<() => Observable<BeefySignedCommitment>>;105    };106    chain: {107      /**108       * Get header and body of a relay chain block109       **/110      getBlock: AugmentedRpc<(hash?: BlockHash | string | Uint8Array) => Observable<SignedBlock>>;111      /**112       * Get the block hash for a specific block113       **/114      getBlockHash: AugmentedRpc<(blockNumber?: BlockNumber | AnyNumber | Uint8Array) => Observable<BlockHash>>;115      /**116       * Get hash of the last finalized block in the canon chain117       **/118      getFinalizedHead: AugmentedRpc<() => Observable<BlockHash>>;119      /**120       * Retrieves the header for a specific block121       **/122      getHeader: AugmentedRpc<(hash?: BlockHash | string | Uint8Array) => Observable<Header>>;123      /**124       * Retrieves the newest header via subscription125       **/126      subscribeAllHeads: AugmentedRpc<() => Observable<Header>>;127      /**128       * Retrieves the best finalized header via subscription129       **/130      subscribeFinalizedHeads: AugmentedRpc<() => Observable<Header>>;131      /**132       * Retrieves the best header via subscription133       **/134      subscribeNewHeads: AugmentedRpc<() => Observable<Header>>;135    };136    childstate: {137      /**138       * Returns the keys with prefix from a child storage, leave empty to get all the keys139       **/140      getKeys: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;141      /**142       * Returns the keys with prefix from a child storage with pagination support143       **/144      getKeysPaged: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, count: u32 | AnyNumber | Uint8Array, startKey?: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;145      /**146       * Returns a child storage entry at a specific block state147       **/148      getStorage: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<StorageData>>>;149      /**150       * Returns child storage entries for multiple keys at a specific block state151       **/152      getStorageEntries: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: Hash | string | Uint8Array) => Observable<Vec<Option<StorageData>>>>;153      /**154       * Returns the hash of a child storage entry at a block state155       **/156      getStorageHash: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<Hash>>>;157      /**158       * Returns the size of a child storage entry at a block state159       **/160      getStorageSize: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<u64>>>;161    };162    contracts: {163      /**164       * @deprecated Use the runtime interface `api.call.contractsApi.call` instead165       * Executes a call to a contract166       **/167      call: AugmentedRpc<(callRequest: ContractCallRequest | { origin?: any; dest?: any; value?: any; gasLimit?: any; storageDepositLimit?: any; inputData?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractExecResult>>;168      /**169       * @deprecated Use the runtime interface `api.call.contractsApi.getStorage` instead170       * Returns the value under a specified storage key in a contract171       **/172      getStorage: AugmentedRpc<(address: AccountId | string | Uint8Array, key: H256 | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Option<Bytes>>>;173      /**174       * @deprecated Use the runtime interface `api.call.contractsApi.instantiate` instead175       * Instantiate a new contract176       **/177      instantiate: AugmentedRpc<(request: InstantiateRequestV1 | { origin?: any; value?: any; gasLimit?: any; code?: any; data?: any; salt?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractInstantiateResult>>;178      /**179       * @deprecated Not available in newer versions of the contracts interfaces180       * Returns the projected time a given contract will be able to sustain paying its rent181       **/182      rentProjection: AugmentedRpc<(address: AccountId | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Option<BlockNumber>>>;183      /**184       * @deprecated Use the runtime interface `api.call.contractsApi.uploadCode` instead185       * Upload new code without instantiating a contract from it186       **/187      uploadCode: AugmentedRpc<(uploadRequest: CodeUploadRequest | { origin?: any; code?: any; storageDepositLimit?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<CodeUploadResult>>;188    };189    dev: {190      /**191       * Reexecute the specified `block_hash` and gather statistics while doing so192       **/193      getBlockStats: AugmentedRpc<(at: Hash | string | Uint8Array) => Observable<Option<BlockStats>>>;194    };195    engine: {196      /**197       * Instructs the manual-seal authorship task to create a new block198       **/199      createBlock: AugmentedRpc<(createEmpty: bool | boolean | Uint8Array, finalize: bool | boolean | Uint8Array, parentHash?: BlockHash | string | Uint8Array) => Observable<CreatedBlock>>;200      /**201       * Instructs the manual-seal authorship task to finalize a block202       **/203      finalizeBlock: AugmentedRpc<(hash: BlockHash | string | Uint8Array, justification?: Justification) => Observable<bool>>;204    };205    eth: {206      /**207       * Returns accounts list.208       **/209      accounts: AugmentedRpc<() => Observable<Vec<H160>>>;210      /**211       * Returns the blockNumber212       **/213      blockNumber: AugmentedRpc<() => Observable<U256>>;214      /**215       * Call contract, returning the output data.216       **/217      call: AugmentedRpc<(request: EthCallRequest | { from?: any; to?: any; gasPrice?: any; gas?: any; value?: any; data?: any; nonce?: any } | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<Bytes>>;218      /**219       * Returns the chain ID used for transaction signing at the current best block. None is returned if not available.220       **/221      chainId: AugmentedRpc<() => Observable<U64>>;222      /**223       * Returns block author.224       **/225      coinbase: AugmentedRpc<() => Observable<H160>>;226      /**227       * Estimate gas needed for execution of given contract.228       **/229      estimateGas: AugmentedRpc<(request: EthCallRequest | { from?: any; to?: any; gasPrice?: any; gas?: any; value?: any; data?: any; nonce?: any } | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;230      /**231       * Returns fee history for given block count & reward percentiles232       **/233      feeHistory: AugmentedRpc<(blockCount: U256 | AnyNumber | Uint8Array, newestBlock: BlockNumber | AnyNumber | Uint8Array, rewardPercentiles: Option<Vec<f64>> | null | Uint8Array | Vec<f64> | (f64)[]) => Observable<EthFeeHistory>>;234      /**235       * Returns current gas price.236       **/237      gasPrice: AugmentedRpc<() => Observable<U256>>;238      /**239       * Returns balance of the given account.240       **/241      getBalance: AugmentedRpc<(address: H160 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;242      /**243       * Returns block with given hash.244       **/245      getBlockByHash: AugmentedRpc<(hash: H256 | string | Uint8Array, full: bool | boolean | Uint8Array) => Observable<Option<EthRichBlock>>>;246      /**247       * Returns block with given number.248       **/249      getBlockByNumber: AugmentedRpc<(block: BlockNumber | AnyNumber | Uint8Array, full: bool | boolean | Uint8Array) => Observable<Option<EthRichBlock>>>;250      /**251       * Returns the number of transactions in a block with given hash.252       **/253      getBlockTransactionCountByHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<U256>>;254      /**255       * Returns the number of transactions in a block with given block number.256       **/257      getBlockTransactionCountByNumber: AugmentedRpc<(block: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;258      /**259       * Returns the code at given address at given time (block number).260       **/261      getCode: AugmentedRpc<(address: H160 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<Bytes>>;262      /**263       * Returns filter changes since last poll.264       **/265      getFilterChanges: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<EthFilterChanges>>;266      /**267       * Returns all logs matching given filter (in a range 'from' - 'to').268       **/269      getFilterLogs: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<Vec<EthLog>>>;270      /**271       * Returns logs matching given filter object.272       **/273      getLogs: AugmentedRpc<(filter: EthFilter | { fromBlock?: any; toBlock?: any; blockHash?: any; address?: any; topics?: any } | string | Uint8Array) => Observable<Vec<EthLog>>>;274      /**275       * Returns proof for account and storage.276       **/277      getProof: AugmentedRpc<(address: H160 | string | Uint8Array, storageKeys: Vec<H256> | (H256 | string | Uint8Array)[], number: BlockNumber | AnyNumber | Uint8Array) => Observable<EthAccount>>;278      /**279       * Returns content of the storage at given address.280       **/281      getStorageAt: AugmentedRpc<(address: H160 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<H256>>;282      /**283       * Returns transaction at given block hash and index.284       **/285      getTransactionByBlockHashAndIndex: AugmentedRpc<(hash: H256 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthTransaction>>;286      /**287       * Returns transaction by given block number and index.288       **/289      getTransactionByBlockNumberAndIndex: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthTransaction>>;290      /**291       * Get transaction by its hash.292       **/293      getTransactionByHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<EthTransaction>>;294      /**295       * Returns the number of transactions sent from given address at given time (block number).296       **/297      getTransactionCount: AugmentedRpc<(address: H160 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;298      /**299       * Returns transaction receipt by transaction hash.300       **/301      getTransactionReceipt: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<EthReceipt>>;302      /**303       * Returns an uncles at given block and index.304       **/305      getUncleByBlockHashAndIndex: AugmentedRpc<(hash: H256 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthRichBlock>>;306      /**307       * Returns an uncles at given block and index.308       **/309      getUncleByBlockNumberAndIndex: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthRichBlock>>;310      /**311       * Returns the number of uncles in a block with given hash.312       **/313      getUncleCountByBlockHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<U256>>;314      /**315       * Returns the number of uncles in a block with given block number.316       **/317      getUncleCountByBlockNumber: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;318      /**319       * Returns the hash of the current block, the seedHash, and the boundary condition to be met.320       **/321      getWork: AugmentedRpc<() => Observable<EthWork>>;322      /**323       * Returns the number of hashes per second that the node is mining with.324       **/325      hashrate: AugmentedRpc<() => Observable<U256>>;326      /**327       * Returns max priority fee per gas328       **/329      maxPriorityFeePerGas: AugmentedRpc<() => Observable<U256>>;330      /**331       * Returns true if client is actively mining new blocks.332       **/333      mining: AugmentedRpc<() => Observable<bool>>;334      /**335       * Returns id of new block filter.336       **/337      newBlockFilter: AugmentedRpc<() => Observable<U256>>;338      /**339       * Returns id of new filter.340       **/341      newFilter: AugmentedRpc<(filter: EthFilter | { fromBlock?: any; toBlock?: any; blockHash?: any; address?: any; topics?: any } | string | Uint8Array) => Observable<U256>>;342      /**343       * Returns id of new block filter.344       **/345      newPendingTransactionFilter: AugmentedRpc<() => Observable<U256>>;346      /**347       * Returns protocol version encoded as a string (quotes are necessary).348       **/349      protocolVersion: AugmentedRpc<() => Observable<u64>>;350      /**351       * Sends signed transaction, returning its hash.352       **/353      sendRawTransaction: AugmentedRpc<(bytes: Bytes | string | Uint8Array) => Observable<H256>>;354      /**355       * Sends transaction; will block waiting for signer to return the transaction hash356       **/357      sendTransaction: AugmentedRpc<(tx: EthTransactionRequest | { from?: any; to?: any; gasPrice?: any; gas?: any; value?: any; data?: any; nonce?: any } | string | Uint8Array) => Observable<H256>>;358      /**359       * Used for submitting mining hashrate.360       **/361      submitHashrate: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array, hash: H256 | string | Uint8Array) => Observable<bool>>;362      /**363       * Used for submitting a proof-of-work solution.364       **/365      submitWork: AugmentedRpc<(nonce: H64 | string | Uint8Array, headerHash: H256 | string | Uint8Array, mixDigest: H256 | string | Uint8Array) => Observable<bool>>;366      /**367       * Subscribe to Eth subscription.368       **/369      subscribe: AugmentedRpc<(kind: EthSubKind | 'newHeads' | 'logs' | 'newPendingTransactions' | 'syncing' | number | Uint8Array, params?: EthSubParams | { None: any } | { Logs: any } | string | Uint8Array) => Observable<Null>>;370      /**371       * Returns an object with data about the sync status or false.372       **/373      syncing: AugmentedRpc<() => Observable<EthSyncStatus>>;374      /**375       * Uninstalls filter.376       **/377      uninstallFilter: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<bool>>;378    };379    grandpa: {380      /**381       * Prove finality for the given block number, returning the Justification for the last block in the set.382       **/383      proveFinality: AugmentedRpc<(blockNumber: BlockNumber | AnyNumber | Uint8Array) => Observable<Option<EncodedFinalityProofs>>>;384      /**385       * Returns the state of the current best round state as well as the ongoing background rounds386       **/387      roundState: AugmentedRpc<() => Observable<ReportedRoundStates>>;388      /**389       * Subscribes to grandpa justifications390       **/391      subscribeJustifications: AugmentedRpc<() => Observable<JustificationNotification>>;392    };393    mmr: {394      /**395       * Generate MMR proof for the given block numbers.396       **/397      generateProof: AugmentedRpc<(blockNumbers: Vec<u64> | (u64 | AnyNumber | Uint8Array)[], bestKnownBlockNumber?: u64 | AnyNumber | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<MmrLeafBatchProof>>;398      /**399       * Get the MMR root hash for the current best block.400       **/401      root: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<MmrHash>>;402      /**403       * Verify an MMR proof404       **/405      verifyProof: AugmentedRpc<(proof: MmrLeafBatchProof | { blockHash?: any; leaves?: any; proof?: any } | string | Uint8Array) => Observable<bool>>;406      /**407       * Verify an MMR proof statelessly given an mmr_root408       **/409      verifyProofStateless: AugmentedRpc<(root: MmrHash | string | Uint8Array, proof: MmrLeafBatchProof | { blockHash?: any; leaves?: any; proof?: any } | string | Uint8Array) => Observable<bool>>;410    };411    net: {412      /**413       * Returns true if client is actively listening for network connections. Otherwise false.414       **/415      listening: AugmentedRpc<() => Observable<bool>>;416      /**417       * Returns number of peers connected to node.418       **/419      peerCount: AugmentedRpc<() => Observable<Text>>;420      /**421       * Returns protocol version.422       **/423      version: AugmentedRpc<() => Observable<Text>>;424    };425    offchain: {426      /**427       * Get offchain local storage under given key and prefix428       **/429      localStorageGet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array) => Observable<Option<Bytes>>>;430      /**431       * Set offchain local storage under given key and prefix432       **/433      localStorageSet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => Observable<Null>>;434    };435    payment: {436      /**437       * @deprecated Use `api.call.transactionPaymentApi.queryFeeDetails` instead438       * Query the detailed fee of a given encoded extrinsic439       **/440      queryFeeDetails: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<FeeDetails>>;441      /**442       * @deprecated Use `api.call.transactionPaymentApi.queryInfo` instead443       * Retrieves the fee information for an encoded extrinsic444       **/445      queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<RuntimeDispatchInfoV1>>;446    };447    povinfo: {448      /**449       * Estimate PoV size of encoded signed extrinsics450       **/451      estimateExtrinsicPoV: AugmentedRpc<(encodedXt: Vec<Bytes> | (Bytes | string | Uint8Array)[], at?: Hash | string | Uint8Array) => Observable<UpPovEstimateRpcPovInfo>>;452    };453    rpc: {454      /**455       * Retrieves the list of RPC methods that are exposed by the node456       **/457      methods: AugmentedRpc<() => Observable<RpcMethods>>;458    };459    state: {460      /**461       * Perform a call to a builtin on the chain462       **/463      call: AugmentedRpc<(method: Text | string, data: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Bytes>>;464      /**465       * Retrieves the keys with prefix of a specific child storage466       **/467      getChildKeys: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;468      /**469       * Returns proof of storage for child key entries at a specific block state.470       **/471      getChildReadProof: AugmentedRpc<(childStorageKey: PrefixedStorageKey | string | Uint8Array, keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: BlockHash | string | Uint8Array) => Observable<ReadProof>>;472      /**473       * Retrieves the child storage for a key474       **/475      getChildStorage: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<StorageData>>;476      /**477       * Retrieves the child storage hash478       **/479      getChildStorageHash: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Hash>>;480      /**481       * Retrieves the child storage size482       **/483      getChildStorageSize: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<u64>>;484      /**485       * @deprecated Use `api.rpc.state.getKeysPaged` to retrieve keys486       * Retrieves the keys with a certain prefix487       **/488      getKeys: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;489      /**490       * Returns the keys with prefix with pagination support.491       **/492      getKeysPaged: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, count: u32 | AnyNumber | Uint8Array, startKey?: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;493      /**494       * Returns the runtime metadata495       **/496      getMetadata: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<Metadata>>;497      /**498       * @deprecated Use `api.rpc.state.getKeysPaged` to retrieve keys499       * Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)500       **/501      getPairs: AugmentedRpc<(prefix: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<KeyValue>>>;502      /**503       * Returns proof of storage entries at a specific block state504       **/505      getReadProof: AugmentedRpc<(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: BlockHash | string | Uint8Array) => Observable<ReadProof>>;506      /**507       * Get the runtime version508       **/509      getRuntimeVersion: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<RuntimeVersion>>;510      /**511       * Retrieves the storage for a key512       **/513      getStorage: AugmentedRpc<<T = Codec>(key: StorageKey | string | Uint8Array | any, block?: Hash | Uint8Array | string) => Observable<T>>;514      /**515       * Retrieves the storage hash516       **/517      getStorageHash: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Hash>>;518      /**519       * Retrieves the storage size520       **/521      getStorageSize: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<u64>>;522      /**523       * Query historical storage entries (by key) starting from a start block524       **/525      queryStorage: AugmentedRpc<<T = Codec[]>(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], fromBlock?: Hash | Uint8Array | string, toBlock?: Hash | Uint8Array | string) => Observable<[Hash, T][]>>;526      /**527       * Query storage entries (by key) starting at block hash given as the second parameter528       **/529      queryStorageAt: AugmentedRpc<<T = Codec[]>(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: Hash | Uint8Array | string) => Observable<T>>;530      /**531       * Retrieves the runtime version via subscription532       **/533      subscribeRuntimeVersion: AugmentedRpc<() => Observable<RuntimeVersion>>;534      /**535       * Subscribes to storage changes for the provided keys536       **/537      subscribeStorage: AugmentedRpc<<T = Codec[]>(keys?: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[]) => Observable<T>>;538      /**539       * Provides a way to trace the re-execution of a single block540       **/541      traceBlock: AugmentedRpc<(block: Hash | string | Uint8Array, targets: Option<Text> | null | Uint8Array | Text | string, storageKeys: Option<Text> | null | Uint8Array | Text | string, methods: Option<Text> | null | Uint8Array | Text | string) => Observable<TraceBlockResponse>>;542      /**543       * Check current migration state544       **/545      trieMigrationStatus: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<MigrationStatusResult>>;546    };547    syncstate: {548      /**549       * Returns the json-serialized chainspec running the node, with a sync state.550       **/551      genSyncSpec: AugmentedRpc<(raw: bool | boolean | Uint8Array) => Observable<Json>>;552    };553    system: {554      /**555       * Retrieves the next accountIndex as available on the node556       **/557      accountNextIndex: AugmentedRpc<(accountId: AccountId | string | Uint8Array) => Observable<Index>>;558      /**559       * Adds the supplied directives to the current log filter560       **/561      addLogFilter: AugmentedRpc<(directives: Text | string) => Observable<Null>>;562      /**563       * Adds a reserved peer564       **/565      addReservedPeer: AugmentedRpc<(peer: Text | string) => Observable<Text>>;566      /**567       * Retrieves the chain568       **/569      chain: AugmentedRpc<() => Observable<Text>>;570      /**571       * Retrieves the chain type572       **/573      chainType: AugmentedRpc<() => Observable<ChainType>>;574      /**575       * Dry run an extrinsic at a given block576       **/577      dryRun: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ApplyExtrinsicResult>>;578      /**579       * Return health status of the node580       **/581      health: AugmentedRpc<() => Observable<Health>>;582      /**583       * 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 example584       **/585      localListenAddresses: AugmentedRpc<() => Observable<Vec<Text>>>;586      /**587       * Returns the base58-encoded PeerId of the node588       **/589      localPeerId: AugmentedRpc<() => Observable<Text>>;590      /**591       * Retrieves the node name592       **/593      name: AugmentedRpc<() => Observable<Text>>;594      /**595       * Returns current state of the network596       **/597      networkState: AugmentedRpc<() => Observable<NetworkState>>;598      /**599       * Returns the roles the node is running as600       **/601      nodeRoles: AugmentedRpc<() => Observable<Vec<NodeRole>>>;602      /**603       * Returns the currently connected peers604       **/605      peers: AugmentedRpc<() => Observable<Vec<PeerInfo>>>;606      /**607       * Get a custom set of properties as a JSON object, defined in the chain spec608       **/609      properties: AugmentedRpc<() => Observable<ChainProperties>>;610      /**611       * Remove a reserved peer612       **/613      removeReservedPeer: AugmentedRpc<(peerId: Text | string) => Observable<Text>>;614      /**615       * Returns the list of reserved peers616       **/617      reservedPeers: AugmentedRpc<() => Observable<Vec<Text>>>;618      /**619       * Resets the log filter to Substrate defaults620       **/621      resetLogFilter: AugmentedRpc<() => Observable<Null>>;622      /**623       * Returns the state of the syncing of the node624       **/625      syncState: AugmentedRpc<() => Observable<SyncState>>;626      /**627       * Retrieves the version of the node628       **/629      version: AugmentedRpc<() => Observable<Text>>;630    };631    unique: {632      /**633       * Get the amount of any user tokens owned by an account634       **/635      accountBalance: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, account: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u32>>;636      /**637       * Get tokens owned by an account in a collection638       **/639      accountTokens: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, account: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<u32>>>;640      /**641       * Get the list of admin accounts of a collection642       **/643      adminlist: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<PalletEvmAccountBasicCrossAccountIdRepr>>>;644      /**645       * Get the amount of currently possible sponsored transactions on a token for the fee to be taken off a sponsor646       **/647      allowance: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, sender: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, spender: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u128>>;648      /**649       * Tells whether the given `owner` approves the `operator`.650       **/651      allowanceForAll: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, owner: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<bool>>>;652      /**653       * Check if a user is allowed to operate within a collection654       **/655      allowed: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, account: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<bool>>;656      /**657       * Get the list of accounts allowed to operate within a collection658       **/659      allowlist: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<PalletEvmAccountBasicCrossAccountIdRepr>>>;660      /**661       * Get the amount of a specific token owned by an account662       **/663      balance: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, account: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u128>>;664      /**665       * Get a collection by the specified ID666       **/667      collectionById: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<UpDataStructsRpcCollection>>>;668      /**669       * Get collection properties, optionally limited to the provided keys670       **/671      collectionProperties: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, propertyKeys?: Option<Vec<Text>> | null | Uint8Array | Vec<Text> | (Text | string)[], at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsProperty>>>;672      /**673       * Get chain stats about collections674       **/675      collectionStats: AugmentedRpc<(at?: Hash | string | Uint8Array) => Observable<UpDataStructsCollectionStats>>;676      /**677       * Get tokens contained within a collection678       **/679      collectionTokens: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<u32>>>;680      /**681       * Get token constant metadata682       **/683      constMetadata: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Bytes>>;684      /**685       * Get effective collection limits686       **/687      effectiveCollectionLimits: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<UpDataStructsCollectionLimits>>>;688      /**689       * Get the last token ID created in a collection690       **/691      lastTokenId: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u32>>;692      /**693       * Get the number of blocks until sponsoring a transaction is available694       **/695      nextSponsored: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, account: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<u64>>>;696      /**697       * Get property permissions, optionally limited to the provided keys698       **/699      propertyPermissions: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, propertyKeys?: Option<Vec<Text>> | null | Uint8Array | Vec<Text> | (Text | string)[], at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsPropertyKeyPermission>>>;700      /**701       * Get tokens nested directly into the token702       **/703      tokenChildren: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsTokenChild>>>;704      /**705       * Get token data, including properties, optionally limited to the provided keys, and total pieces for an RFT706       **/707      tokenData: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys?: Option<Vec<Text>> | null | Uint8Array | Vec<Text> | (Text | string)[], at?: Hash | string | Uint8Array) => Observable<UpDataStructsTokenData>>;708      /**709       * Check if the token exists710       **/711      tokenExists: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<bool>>;712      /**713       * Get the token owner714       **/715      tokenOwner: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<PalletEvmAccountBasicCrossAccountIdRepr>>>;716      /**717       * Returns 10 tokens owners in no particular order718       **/719      tokenOwners: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<PalletEvmAccountBasicCrossAccountIdRepr>>>;720      /**721       * Get token properties, optionally limited to the provided keys722       **/723      tokenProperties: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys?: Option<Vec<Text>> | null | Uint8Array | Vec<Text> | (Text | string)[], at?: Hash | string | Uint8Array) => Observable<Vec<UpDataStructsProperty>>>;724      /**725       * Get the topmost token owner in the hierarchy of a possibly nested token726       **/727      topmostTokenOwner: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<PalletEvmAccountBasicCrossAccountIdRepr>>>;728      /**729       * Get the total amount of pieces of an RFT730       **/731      totalPieces: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Option<u128>>>;732      /**733       * Get the amount of distinctive tokens present in a collection734       **/735      totalSupply: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u32>>;736      /**737       * Get token variable metadata738       **/739      variableMetadata: AugmentedRpc<(collection: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Bytes>>;740    };741    web3: {742      /**743       * Returns current client version.744       **/745      clientVersion: AugmentedRpc<() => Observable<Text>>;746      /**747       * Returns sha3 of the given data748       **/749      sha3: AugmentedRpc<(data: Bytes | string | Uint8Array) => Observable<H256>>;750    };751  } // RpcInterface752} // declare module