@dedot/api 0.0.1-alpha.32

package/chaintypes/substrate/runtime.d.ts

@@ -0,0 +1,850 @@
+import type { AccountId32, AccountId32Like, Bytes, BytesLike, DispatchError, H256, Header, Result, RuntimeVersion, UncheckedExtrinsic, UncheckedExtrinsicLike } from '@dedot/codecs';
+import type { GenericRuntimeApiMethod, GenericRuntimeApis, RpcVersion } from '@dedot/types';
+import type { FrameSupportTokensFungibleUnionOfNativeOrWithId, KitchensinkRuntimeRuntimeCallLike, PalletContractsPrimitivesCode, PalletContractsPrimitivesCodeUploadReturnValue, PalletContractsPrimitivesContractAccessError, PalletContractsPrimitivesContractResult, PalletContractsPrimitivesContractResultResult, PalletContractsWasmDeterminism, PalletTransactionPaymentFeeDetails, PalletTransactionPaymentRuntimeDispatchInfo, SpAuthorityDiscoveryAppPublic, SpConsensusBabeAppPublic, SpConsensusBabeBabeConfiguration, SpConsensusBabeEpoch, SpConsensusBabeOpaqueKeyOwnershipProof, SpConsensusBeefyEcdsaCryptoPublic, SpConsensusBeefyEquivocationProof, SpConsensusBeefyOpaqueKeyOwnershipProof, SpConsensusBeefyValidatorSet, SpConsensusGrandpaAppPublic, SpConsensusGrandpaEquivocationProof, SpConsensusGrandpaOpaqueKeyOwnershipProof, SpConsensusSlotsEquivocationProof, SpConsensusSlotsSlot, SpCoreCryptoKeyTypeId, SpCoreOpaqueMetadata, SpInherentsCheckInherentsResult, SpInherentsInherentData, SpMixnetMixnode, SpMixnetMixnodesErr, SpMixnetSessionStatus, SpMmrPrimitivesEncodableOpaqueLeaf, SpMmrPrimitivesError, SpMmrPrimitivesProof, SpRuntimeBlock, SpRuntimeExtrinsicInclusionMode, SpRuntimeTransactionValidityTransactionSource, SpRuntimeTransactionValidityTransactionValidityError, SpRuntimeTransactionValidityValidTransaction, SpStatementStoreRuntimeApiInvalidStatement, SpStatementStoreRuntimeApiStatementSource, SpStatementStoreRuntimeApiValidStatement, SpStatementStoreStatement, SpWeightsWeightV2Weight } from './types.js';
+export interface RuntimeApis<Rv extends RpcVersion> extends GenericRuntimeApis<Rv> {
+    /**
+     * @runtimeapi: Core - 0xdf6acb689907609b
+     **/
+    core: {
+        /**
+         * Returns the version of the runtime.
+         *
+         * @callname: Core_version
+         **/
+        version: GenericRuntimeApiMethod<Rv, () => Promise<RuntimeVersion>>;
+        /**
+         * Execute the given block.
+         *
+         * @callname: Core_execute_block
+         * @param {SpRuntimeBlock} block
+         **/
+        executeBlock: GenericRuntimeApiMethod<Rv, (block: SpRuntimeBlock) => Promise<[]>>;
+        /**
+         * Initialize a block with the given header and return the runtime executive mode.
+         *
+         * @callname: Core_initialize_block
+         * @param {Header} header
+         **/
+        initializeBlock: GenericRuntimeApiMethod<Rv, (header: Header) => Promise<SpRuntimeExtrinsicInclusionMode>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: Metadata - 0x37e397fc7c91f5e4
+     **/
+    metadata: {
+        /**
+         * Returns the metadata of a runtime.
+         *
+         * @callname: Metadata_metadata
+         **/
+        metadata: GenericRuntimeApiMethod<Rv, () => Promise<SpCoreOpaqueMetadata>>;
+        /**
+         * Returns the metadata at a given version.
+         *
+         * If the given `version` isn't supported, this will return `None`.
+         * Use [`Self::metadata_versions`] to find out about supported metadata version of the runtime.
+         *
+         * @callname: Metadata_metadata_at_version
+         * @param {number} version
+         **/
+        metadataAtVersion: GenericRuntimeApiMethod<Rv, (version: number) => Promise<SpCoreOpaqueMetadata | undefined>>;
+        /**
+         * Returns the supported metadata versions.
+         *
+         * This can be used to call `metadata_at_version`.
+         *
+         * @callname: Metadata_metadata_versions
+         **/
+        metadataVersions: GenericRuntimeApiMethod<Rv, () => Promise<Array<number>>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: BlockBuilder - 0x40fe3ad401f8959a
+     **/
+    blockBuilder: {
+        /**
+         * Apply the given extrinsic.
+         *
+         * Returns an inclusion outcome which specifies if this extrinsic is included in
+         * this block or not.
+         *
+         * @callname: BlockBuilder_apply_extrinsic
+         * @param {UncheckedExtrinsicLike} extrinsic
+         **/
+        applyExtrinsic: GenericRuntimeApiMethod<Rv, (extrinsic: UncheckedExtrinsicLike) => Promise<Result<Result<[], DispatchError>, SpRuntimeTransactionValidityTransactionValidityError>>>;
+        /**
+         * Finish the current block.
+         *
+         * @callname: BlockBuilder_finalize_block
+         **/
+        finalizeBlock: GenericRuntimeApiMethod<Rv, () => Promise<Header>>;
+        /**
+         * Generate inherent extrinsics. The inherent data will vary from chain to chain.
+         *
+         * @callname: BlockBuilder_inherent_extrinsics
+         * @param {SpInherentsInherentData} inherent
+         **/
+        inherentExtrinsics: GenericRuntimeApiMethod<Rv, (inherent: SpInherentsInherentData) => Promise<Array<UncheckedExtrinsic>>>;
+        /**
+         * Check that the inherents are valid. The inherent data will vary from chain to chain.
+         *
+         * @callname: BlockBuilder_check_inherents
+         * @param {SpRuntimeBlock} block
+         * @param {SpInherentsInherentData} data
+         **/
+        checkInherents: GenericRuntimeApiMethod<Rv, (block: SpRuntimeBlock, data: SpInherentsInherentData) => Promise<SpInherentsCheckInherentsResult>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: TaggedTransactionQueue - 0xd2bc9897eed08f15
+     **/
+    taggedTransactionQueue: {
+        /**
+         * Validate the transaction.
+         *
+         * This method is invoked by the transaction pool to learn details about given transaction.
+         * The implementation should make sure to verify the correctness of the transaction
+         * against current state. The given `block_hash` corresponds to the hash of the block
+         * that is used as current state.
+         *
+         * Note that this call may be performed by the pool multiple times and transactions
+         * might be verified in any possible order.
+         *
+         * @callname: TaggedTransactionQueue_validate_transaction
+         * @param {SpRuntimeTransactionValidityTransactionSource} source
+         * @param {UncheckedExtrinsicLike} tx
+         * @param {H256} block_hash
+         **/
+        validateTransaction: GenericRuntimeApiMethod<Rv, (source: SpRuntimeTransactionValidityTransactionSource, tx: UncheckedExtrinsicLike, blockHash: H256) => Promise<Result<SpRuntimeTransactionValidityValidTransaction, SpRuntimeTransactionValidityTransactionValidityError>>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: ValidateStatement - 0xbe9fb0c91a8046cf
+     **/
+    validateStatement: {
+        /**
+         * Validate the statement.
+         *
+         * @callname: ValidateStatement_validate_statement
+         * @param {SpStatementStoreRuntimeApiStatementSource} source
+         * @param {SpStatementStoreStatement} statement
+         **/
+        validateStatement: GenericRuntimeApiMethod<Rv, (source: SpStatementStoreRuntimeApiStatementSource, statement: SpStatementStoreStatement) => Promise<Result<SpStatementStoreRuntimeApiValidStatement, SpStatementStoreRuntimeApiInvalidStatement>>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: OffchainWorkerApi - 0xf78b278be53f454c
+     **/
+    offchainWorkerApi: {
+        /**
+         * Starts the off-chain task for given block header.
+         *
+         * @callname: OffchainWorkerApi_offchain_worker
+         * @param {Header} header
+         **/
+        offchainWorker: GenericRuntimeApiMethod<Rv, (header: Header) => Promise<[]>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: GrandpaApi - 0xed99c5acb25eedf5
+     **/
+    grandpaApi: {
+        /**
+         * Get the current GRANDPA authorities and weights. This should not change except
+         * for when changes are scheduled and the corresponding delay has passed.
+         *
+         * When called at block B, it will return the set of authorities that should be
+         * used to finalize descendants of this block (B+1, B+2, ...). The block B itself
+         * is finalized by the authorities from block B-1.
+         *
+         * @callname: GrandpaApi_grandpa_authorities
+         **/
+        grandpaAuthorities: GenericRuntimeApiMethod<Rv, () => Promise<Array<[SpConsensusGrandpaAppPublic, bigint]>>>;
+        /**
+         * Submits an unsigned extrinsic to report an equivocation. The caller
+         * must provide the equivocation proof and a key ownership proof
+         * (should be obtained using `generate_key_ownership_proof`). The
+         * extrinsic will be unsigned and should only be accepted for local
+         * authorship (not to be broadcast to the network). This method returns
+         * `None` when creation of the extrinsic fails, e.g. if equivocation
+         * reporting is disabled for the given runtime (i.e. this method is
+         * hardcoded to return `None`). Only useful in an offchain context.
+         *
+         * @callname: GrandpaApi_submit_report_equivocation_unsigned_extrinsic
+         * @param {SpConsensusGrandpaEquivocationProof} equivocation_proof
+         * @param {SpConsensusGrandpaOpaqueKeyOwnershipProof} key_owner_proof
+         **/
+        submitReportEquivocationUnsignedExtrinsic: GenericRuntimeApiMethod<Rv, (equivocationProof: SpConsensusGrandpaEquivocationProof, keyOwnerProof: SpConsensusGrandpaOpaqueKeyOwnershipProof) => Promise<[] | undefined>>;
+        /**
+         * Generates a proof of key ownership for the given authority in the
+         * given set. An example usage of this module is coupled with the
+         * session historical module to prove that a given authority key is
+         * tied to a given staking identity during a specific session. Proofs
+         * of key ownership are necessary for submitting equivocation reports.
+         * NOTE: even though the API takes a `set_id` as parameter the current
+         * implementations ignore this parameter and instead rely on this
+         * method being called at the correct block height, i.e. any point at
+         * which the given set id is live on-chain. Future implementations will
+         * instead use indexed data through an offchain worker, not requiring
+         * older states to be available.
+         *
+         * @callname: GrandpaApi_generate_key_ownership_proof
+         * @param {bigint} set_id
+         * @param {SpConsensusGrandpaAppPublic} authority_id
+         **/
+        generateKeyOwnershipProof: GenericRuntimeApiMethod<Rv, (setId: bigint, authorityId: SpConsensusGrandpaAppPublic) => Promise<SpConsensusGrandpaOpaqueKeyOwnershipProof | undefined>>;
+        /**
+         * Get current GRANDPA authority set id.
+         *
+         * @callname: GrandpaApi_current_set_id
+         **/
+        currentSetId: GenericRuntimeApiMethod<Rv, () => Promise<bigint>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: NominationPoolsApi - 0x17a6bc0d0062aeb3
+     **/
+    nominationPoolsApi: {
+        /**
+         * Returns the pending rewards for the member that the AccountId was given for.
+         *
+         * @callname: NominationPoolsApi_pending_rewards
+         * @param {AccountId32Like} who
+         **/
+        pendingRewards: GenericRuntimeApiMethod<Rv, (who: AccountId32Like) => Promise<bigint>>;
+        /**
+         * Returns the equivalent balance of `points` for a given pool.
+         *
+         * @callname: NominationPoolsApi_points_to_balance
+         * @param {number} pool_id
+         * @param {bigint} points
+         **/
+        pointsToBalance: GenericRuntimeApiMethod<Rv, (poolId: number, points: bigint) => Promise<bigint>>;
+        /**
+         * Returns the equivalent points of `new_funds` for a given pool.
+         *
+         * @callname: NominationPoolsApi_balance_to_points
+         * @param {number} pool_id
+         * @param {bigint} new_funds
+         **/
+        balanceToPoints: GenericRuntimeApiMethod<Rv, (poolId: number, newFunds: bigint) => Promise<bigint>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: StakingApi - 0x18ef58a3b67ba770
+     **/
+    stakingApi: {
+        /**
+         * Returns the nominations quota for a nominator with a given balance.
+         *
+         * @callname: StakingApi_nominations_quota
+         * @param {bigint} balance
+         **/
+        nominationsQuota: GenericRuntimeApiMethod<Rv, (balance: bigint) => Promise<number>>;
+        /**
+         * Returns the page count of exposures for a validator in a given era.
+         *
+         * @callname: StakingApi_eras_stakers_page_count
+         * @param {number} era
+         * @param {AccountId32Like} account
+         **/
+        erasStakersPageCount: GenericRuntimeApiMethod<Rv, (era: number, account: AccountId32Like) => Promise<number>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: BabeApi - 0xcbca25e39f142387
+     **/
+    babeApi: {
+        /**
+         * Return the configuration for BABE.
+         *
+         * @callname: BabeApi_configuration
+         **/
+        configuration: GenericRuntimeApiMethod<Rv, () => Promise<SpConsensusBabeBabeConfiguration>>;
+        /**
+         * Returns the slot that started the current epoch.
+         *
+         * @callname: BabeApi_current_epoch_start
+         **/
+        currentEpochStart: GenericRuntimeApiMethod<Rv, () => Promise<SpConsensusSlotsSlot>>;
+        /**
+         * Returns information regarding the current epoch.
+         *
+         * @callname: BabeApi_current_epoch
+         **/
+        currentEpoch: GenericRuntimeApiMethod<Rv, () => Promise<SpConsensusBabeEpoch>>;
+        /**
+         * Returns information regarding the next epoch (which was already
+         * previously announced).
+         *
+         * @callname: BabeApi_next_epoch
+         **/
+        nextEpoch: GenericRuntimeApiMethod<Rv, () => Promise<SpConsensusBabeEpoch>>;
+        /**
+         * Generates a proof of key ownership for the given authority in the
+         * current epoch. An example usage of this module is coupled with the
+         * session historical module to prove that a given authority key is
+         * tied to a given staking identity during a specific session. Proofs
+         * of key ownership are necessary for submitting equivocation reports.
+         * NOTE: even though the API takes a `slot` as parameter the current
+         * implementations ignores this parameter and instead relies on this
+         * method being called at the correct block height, i.e. any point at
+         * which the epoch for the given slot is live on-chain. Future
+         * implementations will instead use indexed data through an offchain
+         * worker, not requiring older states to be available.
+         *
+         * @callname: BabeApi_generate_key_ownership_proof
+         * @param {SpConsensusSlotsSlot} slot
+         * @param {SpConsensusBabeAppPublic} authority_id
+         **/
+        generateKeyOwnershipProof: GenericRuntimeApiMethod<Rv, (slot: SpConsensusSlotsSlot, authorityId: SpConsensusBabeAppPublic) => Promise<SpConsensusBabeOpaqueKeyOwnershipProof | undefined>>;
+        /**
+         * Submits an unsigned extrinsic to report an equivocation. The caller
+         * must provide the equivocation proof and a key ownership proof
+         * (should be obtained using `generate_key_ownership_proof`). The
+         * extrinsic will be unsigned and should only be accepted for local
+         * authorship (not to be broadcast to the network). This method returns
+         * `None` when creation of the extrinsic fails, e.g. if equivocation
+         * reporting is disabled for the given runtime (i.e. this method is
+         * hardcoded to return `None`). Only useful in an offchain context.
+         *
+         * @callname: BabeApi_submit_report_equivocation_unsigned_extrinsic
+         * @param {SpConsensusSlotsEquivocationProof} equivocation_proof
+         * @param {SpConsensusBabeOpaqueKeyOwnershipProof} key_owner_proof
+         **/
+        submitReportEquivocationUnsignedExtrinsic: GenericRuntimeApiMethod<Rv, (equivocationProof: SpConsensusSlotsEquivocationProof, keyOwnerProof: SpConsensusBabeOpaqueKeyOwnershipProof) => Promise<[] | undefined>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: AuthorityDiscoveryApi - 0x687ad44ad37f03c2
+     **/
+    authorityDiscoveryApi: {
+        /**
+         * Retrieve authority identifiers of the current and next authority set.
+         *
+         * @callname: AuthorityDiscoveryApi_authorities
+         **/
+        authorities: GenericRuntimeApiMethod<Rv, () => Promise<Array<SpAuthorityDiscoveryAppPublic>>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: AccountNonceApi - 0xbc9d89904f5b923f
+     **/
+    accountNonceApi: {
+        /**
+         * Get current account nonce of given `AccountId`.
+         *
+         * @callname: AccountNonceApi_account_nonce
+         * @param {AccountId32Like} account
+         **/
+        accountNonce: GenericRuntimeApiMethod<Rv, (account: AccountId32Like) => Promise<number>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: AssetsApi - 0x8453b50b22293977
+     **/
+    assetsApi: {
+        /**
+         * Returns the list of `AssetId`s and corresponding balance that an `AccountId` has.
+         *
+         * @callname: AssetsApi_account_balances
+         * @param {AccountId32Like} account
+         **/
+        accountBalances: GenericRuntimeApiMethod<Rv, (account: AccountId32Like) => Promise<Array<[number, bigint]>>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: ContractsApi - 0x68b66ba122c93fa7
+     **/
+    contractsApi: {
+        /**
+         * Perform a call from a specified account to a given contract.
+         *
+         * See [`crate::Pallet::bare_call`].
+         *
+         * @callname: ContractsApi_call
+         * @param {AccountId32Like} origin
+         * @param {AccountId32Like} dest
+         * @param {bigint} value
+         * @param {SpWeightsWeightV2Weight | undefined} gas_limit
+         * @param {bigint | undefined} storage_deposit_limit
+         * @param {BytesLike} input_data
+         **/
+        call: GenericRuntimeApiMethod<Rv, (origin: AccountId32Like, dest: AccountId32Like, value: bigint, gasLimit: SpWeightsWeightV2Weight | undefined, storageDepositLimit: bigint | undefined, inputData: BytesLike) => Promise<PalletContractsPrimitivesContractResult>>;
+        /**
+         * Instantiate a new contract.
+         *
+         * See `[crate::Pallet::bare_instantiate]`.
+         *
+         * @callname: ContractsApi_instantiate
+         * @param {AccountId32Like} origin
+         * @param {bigint} value
+         * @param {SpWeightsWeightV2Weight | undefined} gas_limit
+         * @param {bigint | undefined} storage_deposit_limit
+         * @param {PalletContractsPrimitivesCode} code
+         * @param {BytesLike} data
+         * @param {BytesLike} salt
+         **/
+        instantiate: GenericRuntimeApiMethod<Rv, (origin: AccountId32Like, value: bigint, gasLimit: SpWeightsWeightV2Weight | undefined, storageDepositLimit: bigint | undefined, code: PalletContractsPrimitivesCode, data: BytesLike, salt: BytesLike) => Promise<PalletContractsPrimitivesContractResultResult>>;
+        /**
+         * Upload new code without instantiating a contract from it.
+         *
+         * See [`crate::Pallet::bare_upload_code`].
+         *
+         * @callname: ContractsApi_upload_code
+         * @param {AccountId32Like} origin
+         * @param {BytesLike} code
+         * @param {bigint | undefined} storage_deposit_limit
+         * @param {PalletContractsWasmDeterminism} determinism
+         **/
+        uploadCode: GenericRuntimeApiMethod<Rv, (origin: AccountId32Like, code: BytesLike, storageDepositLimit: bigint | undefined, determinism: PalletContractsWasmDeterminism) => Promise<Result<PalletContractsPrimitivesCodeUploadReturnValue, DispatchError>>>;
+        /**
+         * Query a given storage key in a given contract.
+         *
+         * Returns `Ok(Some(Vec<u8>))` if the storage value exists under the given key in the
+         * specified account and `Ok(None)` if it doesn't. If the account specified by the address
+         * doesn't exist, or doesn't have a contract then `Err` is returned.
+         *
+         * @callname: ContractsApi_get_storage
+         * @param {AccountId32Like} address
+         * @param {BytesLike} key
+         **/
+        getStorage: GenericRuntimeApiMethod<Rv, (address: AccountId32Like, key: BytesLike) => Promise<Result<Bytes | undefined, PalletContractsPrimitivesContractAccessError>>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: TransactionPaymentApi - 0x37c8bb1350a9a2a8
+     **/
+    transactionPaymentApi: {
+        /**
+         *
+         * @callname: TransactionPaymentApi_query_info
+         * @param {UncheckedExtrinsicLike} uxt
+         * @param {number} len
+         **/
+        queryInfo: GenericRuntimeApiMethod<Rv, (uxt: UncheckedExtrinsicLike, len: number) => Promise<PalletTransactionPaymentRuntimeDispatchInfo>>;
+        /**
+         *
+         * @callname: TransactionPaymentApi_query_fee_details
+         * @param {UncheckedExtrinsicLike} uxt
+         * @param {number} len
+         **/
+        queryFeeDetails: GenericRuntimeApiMethod<Rv, (uxt: UncheckedExtrinsicLike, len: number) => Promise<PalletTransactionPaymentFeeDetails>>;
+        /**
+         *
+         * @callname: TransactionPaymentApi_query_weight_to_fee
+         * @param {SpWeightsWeightV2Weight} weight
+         **/
+        queryWeightToFee: GenericRuntimeApiMethod<Rv, (weight: SpWeightsWeightV2Weight) => Promise<bigint>>;
+        /**
+         *
+         * @callname: TransactionPaymentApi_query_length_to_fee
+         * @param {number} length
+         **/
+        queryLengthToFee: GenericRuntimeApiMethod<Rv, (length: number) => Promise<bigint>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: AssetConversionApi - 0x8a8047a53a8277ec
+     **/
+    assetConversionApi: {
+        /**
+         * Provides a quote for [`Pallet::swap_tokens_for_exact_tokens`].
+         *
+         * Note that the price may have changed by the time the transaction is executed.
+         * (Use `amount_in_max` to control slippage.)
+         *
+         * @callname: AssetConversionApi_quote_price_tokens_for_exact_tokens
+         * @param {FrameSupportTokensFungibleUnionOfNativeOrWithId} asset1
+         * @param {FrameSupportTokensFungibleUnionOfNativeOrWithId} asset2
+         * @param {bigint} amount
+         * @param {boolean} include_fee
+         **/
+        quotePriceTokensForExactTokens: GenericRuntimeApiMethod<Rv, (asset1: FrameSupportTokensFungibleUnionOfNativeOrWithId, asset2: FrameSupportTokensFungibleUnionOfNativeOrWithId, amount: bigint, includeFee: boolean) => Promise<bigint | undefined>>;
+        /**
+         * Provides a quote for [`Pallet::swap_exact_tokens_for_tokens`].
+         *
+         * Note that the price may have changed by the time the transaction is executed.
+         * (Use `amount_out_min` to control slippage.)
+         *
+         * @callname: AssetConversionApi_quote_price_exact_tokens_for_tokens
+         * @param {FrameSupportTokensFungibleUnionOfNativeOrWithId} asset1
+         * @param {FrameSupportTokensFungibleUnionOfNativeOrWithId} asset2
+         * @param {bigint} amount
+         * @param {boolean} include_fee
+         **/
+        quotePriceExactTokensForTokens: GenericRuntimeApiMethod<Rv, (asset1: FrameSupportTokensFungibleUnionOfNativeOrWithId, asset2: FrameSupportTokensFungibleUnionOfNativeOrWithId, amount: bigint, includeFee: boolean) => Promise<bigint | undefined>>;
+        /**
+         * Returns the size of the liquidity pool for the given asset pair.
+         *
+         * @callname: AssetConversionApi_get_reserves
+         * @param {FrameSupportTokensFungibleUnionOfNativeOrWithId} asset1
+         * @param {FrameSupportTokensFungibleUnionOfNativeOrWithId} asset2
+         **/
+        getReserves: GenericRuntimeApiMethod<Rv, (asset1: FrameSupportTokensFungibleUnionOfNativeOrWithId, asset2: FrameSupportTokensFungibleUnionOfNativeOrWithId) => Promise<[bigint, bigint] | undefined>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: TransactionPaymentCallApi - 0xf3ff14d5ab527059
+     **/
+    transactionPaymentCallApi: {
+        /**
+         * Query information of a dispatch class, weight, and fee of a given encoded `Call`.
+         *
+         * @callname: TransactionPaymentCallApi_query_call_info
+         * @param {KitchensinkRuntimeRuntimeCallLike} call
+         * @param {number} len
+         **/
+        queryCallInfo: GenericRuntimeApiMethod<Rv, (call: KitchensinkRuntimeRuntimeCallLike, len: number) => Promise<PalletTransactionPaymentRuntimeDispatchInfo>>;
+        /**
+         * Query fee details of a given encoded `Call`.
+         *
+         * @callname: TransactionPaymentCallApi_query_call_fee_details
+         * @param {KitchensinkRuntimeRuntimeCallLike} call
+         * @param {number} len
+         **/
+        queryCallFeeDetails: GenericRuntimeApiMethod<Rv, (call: KitchensinkRuntimeRuntimeCallLike, len: number) => Promise<PalletTransactionPaymentFeeDetails>>;
+        /**
+         * Query the output of the current `WeightToFee` given some input.
+         *
+         * @callname: TransactionPaymentCallApi_query_weight_to_fee
+         * @param {SpWeightsWeightV2Weight} weight
+         **/
+        queryWeightToFee: GenericRuntimeApiMethod<Rv, (weight: SpWeightsWeightV2Weight) => Promise<bigint>>;
+        /**
+         * Query the output of the current `LengthToFee` given some input.
+         *
+         * @callname: TransactionPaymentCallApi_query_length_to_fee
+         * @param {number} length
+         **/
+        queryLengthToFee: GenericRuntimeApiMethod<Rv, (length: number) => Promise<bigint>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: NftsApi - 0x899a250cbe84f250
+     **/
+    nftsApi: {
+        /**
+         *
+         * @callname: NftsApi_owner
+         * @param {number} collection
+         * @param {number} item
+         **/
+        owner: GenericRuntimeApiMethod<Rv, (collection: number, item: number) => Promise<AccountId32 | undefined>>;
+        /**
+         *
+         * @callname: NftsApi_collection_owner
+         * @param {number} collection
+         **/
+        collectionOwner: GenericRuntimeApiMethod<Rv, (collection: number) => Promise<AccountId32 | undefined>>;
+        /**
+         *
+         * @callname: NftsApi_attribute
+         * @param {number} collection
+         * @param {number} item
+         * @param {BytesLike} key
+         **/
+        attribute: GenericRuntimeApiMethod<Rv, (collection: number, item: number, key: BytesLike) => Promise<Bytes | undefined>>;
+        /**
+         *
+         * @callname: NftsApi_custom_attribute
+         * @param {AccountId32Like} account
+         * @param {number} collection
+         * @param {number} item
+         * @param {BytesLike} key
+         **/
+        customAttribute: GenericRuntimeApiMethod<Rv, (account: AccountId32Like, collection: number, item: number, key: BytesLike) => Promise<Bytes | undefined>>;
+        /**
+         *
+         * @callname: NftsApi_system_attribute
+         * @param {number} collection
+         * @param {number | undefined} item
+         * @param {BytesLike} key
+         **/
+        systemAttribute: GenericRuntimeApiMethod<Rv, (collection: number, item: number | undefined, key: BytesLike) => Promise<Bytes | undefined>>;
+        /**
+         *
+         * @callname: NftsApi_collection_attribute
+         * @param {number} collection
+         * @param {BytesLike} key
+         **/
+        collectionAttribute: GenericRuntimeApiMethod<Rv, (collection: number, key: BytesLike) => Promise<Bytes | undefined>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: BeefyApi - 0x49eaaf1b548a0cb0
+     **/
+    beefyApi: {
+        /**
+         * Return the block number where BEEFY consensus is enabled/started
+         *
+         * @callname: BeefyApi_beefy_genesis
+         **/
+        beefyGenesis: GenericRuntimeApiMethod<Rv, () => Promise<number | undefined>>;
+        /**
+         * Return the current active BEEFY validator set
+         *
+         * @callname: BeefyApi_validator_set
+         **/
+        validatorSet: GenericRuntimeApiMethod<Rv, () => Promise<SpConsensusBeefyValidatorSet | undefined>>;
+        /**
+         * Submits an unsigned extrinsic to report an equivocation. The caller
+         * must provide the equivocation proof and a key ownership proof
+         * (should be obtained using `generate_key_ownership_proof`). The
+         * extrinsic will be unsigned and should only be accepted for local
+         * authorship (not to be broadcast to the network). This method returns
+         * `None` when creation of the extrinsic fails, e.g. if equivocation
+         * reporting is disabled for the given runtime (i.e. this method is
+         * hardcoded to return `None`). Only useful in an offchain context.
+         *
+         * @callname: BeefyApi_submit_report_equivocation_unsigned_extrinsic
+         * @param {SpConsensusBeefyEquivocationProof} equivocation_proof
+         * @param {SpConsensusBeefyOpaqueKeyOwnershipProof} key_owner_proof
+         **/
+        submitReportEquivocationUnsignedExtrinsic: GenericRuntimeApiMethod<Rv, (equivocationProof: SpConsensusBeefyEquivocationProof, keyOwnerProof: SpConsensusBeefyOpaqueKeyOwnershipProof) => Promise<[] | undefined>>;
+        /**
+         * Generates a proof of key ownership for the given authority in the
+         * given set. An example usage of this module is coupled with the
+         * session historical module to prove that a given authority key is
+         * tied to a given staking identity during a specific session. Proofs
+         * of key ownership are necessary for submitting equivocation reports.
+         * NOTE: even though the API takes a `set_id` as parameter the current
+         * implementations ignores this parameter and instead relies on this
+         * method being called at the correct block height, i.e. any point at
+         * which the given set id is live on-chain. Future implementations will
+         * instead use indexed data through an offchain worker, not requiring
+         * older states to be available.
+         *
+         * @callname: BeefyApi_generate_key_ownership_proof
+         * @param {bigint} set_id
+         * @param {SpConsensusBeefyEcdsaCryptoPublic} authority_id
+         **/
+        generateKeyOwnershipProof: GenericRuntimeApiMethod<Rv, (setId: bigint, authorityId: SpConsensusBeefyEcdsaCryptoPublic) => Promise<SpConsensusBeefyOpaqueKeyOwnershipProof | undefined>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: MmrApi - 0x91d5df18b0d2cf58
+     **/
+    mmrApi: {
+        /**
+         * Return the on-chain MMR root hash.
+         *
+         * @callname: MmrApi_mmr_root
+         **/
+        mmrRoot: GenericRuntimeApiMethod<Rv, () => Promise<Result<H256, SpMmrPrimitivesError>>>;
+        /**
+         * Return the number of MMR blocks in the chain.
+         *
+         * @callname: MmrApi_mmr_leaf_count
+         **/
+        mmrLeafCount: GenericRuntimeApiMethod<Rv, () => Promise<Result<bigint, SpMmrPrimitivesError>>>;
+        /**
+         * Generate MMR proof for a series of block numbers. If `best_known_block_number = Some(n)`,
+         * use historical MMR state at given block height `n`. Else, use current MMR state.
+         *
+         * @callname: MmrApi_generate_proof
+         * @param {Array<number>} block_numbers
+         * @param {number | undefined} best_known_block_number
+         **/
+        generateProof: GenericRuntimeApiMethod<Rv, (blockNumbers: Array<number>, bestKnownBlockNumber?: number | undefined) => Promise<Result<[Array<SpMmrPrimitivesEncodableOpaqueLeaf>, SpMmrPrimitivesProof], SpMmrPrimitivesError>>>;
+        /**
+         * Verify MMR proof against on-chain MMR for a batch of leaves.
+         *
+         * Note this function will use on-chain MMR root hash and check if the proof matches the hash.
+         * Note, the leaves should be sorted such that corresponding leaves and leaf indices have the
+         * same position in both the `leaves` vector and the `leaf_indices` vector contained in the [Proof]
+         *
+         * @callname: MmrApi_verify_proof
+         * @param {Array<SpMmrPrimitivesEncodableOpaqueLeaf>} leaves
+         * @param {SpMmrPrimitivesProof} proof
+         **/
+        verifyProof: GenericRuntimeApiMethod<Rv, (leaves: Array<SpMmrPrimitivesEncodableOpaqueLeaf>, proof: SpMmrPrimitivesProof) => Promise<Result<[], SpMmrPrimitivesError>>>;
+        /**
+         * Verify MMR proof against given root hash for a batch of leaves.
+         *
+         * Note this function does not require any on-chain storage - the
+         * proof is verified against given MMR root hash.
+         *
+         * Note, the leaves should be sorted such that corresponding leaves and leaf indices have the
+         * same position in both the `leaves` vector and the `leaf_indices` vector contained in the [Proof]
+         *
+         * @callname: MmrApi_verify_proof_stateless
+         * @param {H256} root
+         * @param {Array<SpMmrPrimitivesEncodableOpaqueLeaf>} leaves
+         * @param {SpMmrPrimitivesProof} proof
+         **/
+        verifyProofStateless: GenericRuntimeApiMethod<Rv, (root: H256, leaves: Array<SpMmrPrimitivesEncodableOpaqueLeaf>, proof: SpMmrPrimitivesProof) => Promise<Result<[], SpMmrPrimitivesError>>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: MixnetApi - 0x6fd7c327202e4a8d
+     **/
+    mixnetApi: {
+        /**
+         * Get the index and phase of the current session.
+         *
+         * @callname: MixnetApi_session_status
+         **/
+        sessionStatus: GenericRuntimeApiMethod<Rv, () => Promise<SpMixnetSessionStatus>>;
+        /**
+         * Get the mixnode set for the previous session.
+         *
+         * @callname: MixnetApi_prev_mixnodes
+         **/
+        prevMixnodes: GenericRuntimeApiMethod<Rv, () => Promise<Result<Array<SpMixnetMixnode>, SpMixnetMixnodesErr>>>;
+        /**
+         * Get the mixnode set for the current session.
+         *
+         * @callname: MixnetApi_current_mixnodes
+         **/
+        currentMixnodes: GenericRuntimeApiMethod<Rv, () => Promise<Result<Array<SpMixnetMixnode>, SpMixnetMixnodesErr>>>;
+        /**
+         * Try to register a mixnode for the next session.
+         *
+         * If a registration extrinsic is submitted, `true` is returned. The caller should avoid
+         * calling `maybe_register` again for a few blocks, to give the submitted extrinsic a
+         * chance to get included.
+         *
+         * With the above exception, `maybe_register` is designed to be called every block. Most
+         * of the time it will not do anything, for example:
+         *
+         * - If it is not an appropriate time to submit a registration extrinsic.
+         * - If the local node has already registered a mixnode for the next session.
+         * - If the local node is not permitted to register a mixnode for the next session.
+         *
+         * `session_index` should match `session_status().current_index`; if it does not, `false`
+         * is returned immediately.
+         *
+         * @callname: MixnetApi_maybe_register
+         * @param {number} session_index
+         * @param {SpMixnetMixnode} mixnode
+         **/
+        maybeRegister: GenericRuntimeApiMethod<Rv, (sessionIndex: number, mixnode: SpMixnetMixnode) => Promise<boolean>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: SessionKeys - 0xab3c0572291feb8b
+     **/
+    sessionKeys: {
+        /**
+         * Generate a set of session keys with optionally using the given seed.
+         * The keys should be stored within the keystore exposed via runtime
+         * externalities.
+         *
+         * The seed needs to be a valid `utf8` string.
+         *
+         * Returns the concatenated SCALE encoded public keys.
+         *
+         * @callname: SessionKeys_generate_session_keys
+         * @param {BytesLike | undefined} seed
+         **/
+        generateSessionKeys: GenericRuntimeApiMethod<Rv, (seed?: BytesLike | undefined) => Promise<Bytes>>;
+        /**
+         * Decode the given public session keys.
+         *
+         * Returns the list of public raw public keys + key type.
+         *
+         * @callname: SessionKeys_decode_session_keys
+         * @param {BytesLike} encoded
+         **/
+        decodeSessionKeys: GenericRuntimeApiMethod<Rv, (encoded: BytesLike) => Promise<Array<[Bytes, SpCoreCryptoKeyTypeId]> | undefined>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+    /**
+     * @runtimeapi: GenesisBuilder - 0xfbc577b9d747efd6
+     **/
+    genesisBuilder: {
+        /**
+         * Creates the default `RuntimeGenesisConfig` and returns it as a JSON blob.
+         *
+         * This function instantiates the default `RuntimeGenesisConfig` struct for the runtime and serializes it into a JSON
+         * blob. It returns a `Vec<u8>` containing the JSON representation of the default `RuntimeGenesisConfig`.
+         *
+         * @callname: GenesisBuilder_create_default_config
+         **/
+        createDefaultConfig: GenericRuntimeApiMethod<Rv, () => Promise<Bytes>>;
+        /**
+         * Build `RuntimeGenesisConfig` from a JSON blob not using any defaults and store it in the storage.
+         *
+         * This function deserializes the full `RuntimeGenesisConfig` from the given JSON blob and puts it into the storage.
+         * If the provided JSON blob is incorrect or incomplete or the deserialization fails, an error is returned.
+         * It is recommended to log any errors encountered during the process.
+         *
+         * Please note that provided json blob must contain all `RuntimeGenesisConfig` fields, no defaults will be used.
+         *
+         * @callname: GenesisBuilder_build_config
+         * @param {BytesLike} json
+         **/
+        buildConfig: GenericRuntimeApiMethod<Rv, (json: BytesLike) => Promise<Result<[], string>>>;
+        /**
+         * Generic runtime api call
+         **/
+        [method: string]: GenericRuntimeApiMethod<Rv>;
+    };
+}