1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34import type { EthereumTransactionLegacyTransaction } from './ethereum';5import type { CumulusPrimitivesParachainInherentParachainInherentData } from './polkadot';6import type { PalletCommonAccountBasicCrossAccountIdRepr, UpDataStructsAccessMode, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsMetaUpdatePermission, UpDataStructsSchemaVersion } from './unique';7import type { ApiTypes, SubmittableExtrinsic } from '@polkadot/api/types';8import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types';9import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';10import type { AccountId32, Call, H160, H256, MultiAddress, Perbill } from '@polkadot/types/interfaces/runtime';11import type { XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';12import type { AnyNumber, ITuple } from '@polkadot/types/types';1314declare module '@polkadot/api/types/submittable' {15 export interface AugmentedSubmittables<ApiType> {16 balances: {17 /**18 * Exactly as `transfer`, except the origin must be root and the source account may be19 * specified.20 * # <weight>21 * - Same as transfer, but additional read and write because the source account is not22 * assumed to be in the overlay.23 * # </weight>24 **/25 forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Compact<u128>]>;26 /**27 * Unreserve some balance from a user by force.28 * 29 * Can only be called by ROOT.30 **/31 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;32 /**33 * Set the balances of a given account.34 * 35 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will36 * also decrease the total issuance of the system (`TotalIssuance`).37 * If the new free or reserved balance is below the existential deposit,38 * it will reset the account nonce (`frame_system::AccountNonce`).39 * 40 * The dispatch origin for this call is `root`.41 **/42 setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;43 /**44 * Transfer some liquid free balance to another account.45 * 46 * `transfer` will set the `FreeBalance` of the sender and receiver.47 * It will decrease the total issuance of the system by the `TransferFee`.48 * If the sender's account is below the existential deposit as a result49 * of the transfer, the account will be reaped.50 * 51 * The dispatch origin for this call must be `Signed` by the transactor.52 * 53 * # <weight>54 * - Dependent on arguments but not critical, given proper implementations for input config55 * types. See related functions below.56 * - It contains a limited number of reads and writes internally and no complex57 * computation.58 * 59 * Related functions:60 * 61 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.62 * - Transferring balances to accounts that did not exist before will cause63 * `T::OnNewAccount::on_new_account` to be called.64 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.65 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check66 * that the transfer will not kill the origin account.67 * ---------------------------------68 * - Origin account is already in memory, so no DB operations for them.69 * # </weight>70 **/71 transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;72 /**73 * Transfer the entire transferable balance from the caller account.74 * 75 * NOTE: This function only attempts to transfer _transferable_ balances. This means that76 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be77 * transferred by this function. To ensure that this function results in a killed account,78 * you might need to prepare the account by removing any reference counters, storage79 * deposits, etc...80 * 81 * The dispatch origin of this call must be Signed.82 * 83 * - `dest`: The recipient of the transfer.84 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all85 * of the funds the account has, causing the sender account to be killed (false), or86 * transfer everything except at least the existential deposit, which will guarantee to87 * keep the sender account alive (true). # <weight>88 * - O(1). Just like transfer, but reading the user's transferable balance first.89 * #</weight>90 **/91 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;92 /**93 * Same as the [`transfer`] call, but with a check that the transfer will not kill the94 * origin account.95 * 96 * 99% of the time you want [`transfer`] instead.97 * 98 * [`transfer`]: struct.Pallet.html#method.transfer99 **/100 transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;101 /**102 * Generic tx103 **/104 [key: string]: SubmittableExtrinsicFunction<ApiType>;105 };106 charging: {107 /**108 * Generic tx109 **/110 [key: string]: SubmittableExtrinsicFunction<ApiType>;111 };112 cumulusXcm: {113 /**114 * Generic tx115 **/116 [key: string]: SubmittableExtrinsicFunction<ApiType>;117 };118 dmpQueue: {119 /**120 * Service a single overweight message.121 * 122 * - `origin`: Must pass `ExecuteOverweightOrigin`.123 * - `index`: The index of the overweight message to service.124 * - `weight_limit`: The amount of weight that message execution may take.125 * 126 * Errors:127 * - `Unknown`: Message of `index` is unknown.128 * - `OverLimit`: Message execution may use greater than `weight_limit`.129 * 130 * Events:131 * - `OverweightServiced`: On success.132 **/133 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;134 /**135 * Generic tx136 **/137 [key: string]: SubmittableExtrinsicFunction<ApiType>;138 };139 ethereum: {140 /**141 * Transact an Ethereum transaction.142 **/143 transact: AugmentedSubmittable<(transaction: EthereumTransactionLegacyTransaction | { nonce?: any; gasPrice?: any; gasLimit?: any; action?: any; value?: any; input?: any; signature?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionLegacyTransaction]>;144 /**145 * Generic tx146 **/147 [key: string]: SubmittableExtrinsicFunction<ApiType>;148 };149 evm: {150 /**151 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.152 **/153 call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, gasPrice: U256 | AnyNumber | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>]>;154 /**155 * Issue an EVM create operation. This is similar to a contract creation transaction in156 * Ethereum.157 **/158 create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, gasPrice: U256 | AnyNumber | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>]>;159 /**160 * Issue an EVM create2 operation.161 **/162 create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, gasPrice: U256 | AnyNumber | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>]>;163 /**164 * Withdraw balance from EVM into currency/balances pallet.165 **/166 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;167 /**168 * Generic tx169 **/170 [key: string]: SubmittableExtrinsicFunction<ApiType>;171 };172 evmMigration: {173 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;174 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;175 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;176 /**177 * Generic tx178 **/179 [key: string]: SubmittableExtrinsicFunction<ApiType>;180 };181 inflation: {182 /**183 * This method sets the inflation start date. Can be only called once.184 * Inflation start block can be backdated and will catch up. The method will create Treasury185 * account if it does not exist and perform the first inflation deposit.186 * 187 * # Permissions188 * 189 * * Root190 * 191 * # Arguments192 * 193 * * inflation_start_relay_block: The relay chain block at which inflation should start194 **/195 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;196 /**197 * Generic tx198 **/199 [key: string]: SubmittableExtrinsicFunction<ApiType>;200 };201 parachainSystem: {202 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;203 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;204 /**205 * Set the current validation data.206 * 207 * This should be invoked exactly once per block. It will panic at the finalization208 * phase if the call was not invoked.209 * 210 * The dispatch origin for this call must be `Inherent`211 * 212 * As a side effect, this function upgrades the current validation function213 * if the appropriate time has come.214 **/215 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;216 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;217 /**218 * Generic tx219 **/220 [key: string]: SubmittableExtrinsicFunction<ApiType>;221 };222 polkadotXcm: {223 /**224 * Execute an XCM message from a local, signed, origin.225 * 226 * An event is deposited indicating whether `msg` could be executed completely or only227 * partially.228 * 229 * No more than `max_weight` will be used in its attempted execution. If this is less than the230 * maximum amount of weight that the message could take to be executed, then no execution231 * attempt will be made.232 * 233 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully234 * to completion; only that *some* of it was executed.235 **/236 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;237 /**238 * Set a safe XCM version (the version that XCM should be encoded with if the most recent239 * version a destination can accept is unknown).240 * 241 * - `origin`: Must be Root.242 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.243 **/244 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;245 /**246 * Ask a location to notify us regarding their XCM version and any changes to it.247 * 248 * - `origin`: Must be Root.249 * - `location`: The location to which we should subscribe for XCM version notifications.250 **/251 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;252 /**253 * Require that a particular destination should no longer notify us regarding any XCM254 * version changes.255 * 256 * - `origin`: Must be Root.257 * - `location`: The location to which we are currently subscribed for XCM version258 * notifications which we no longer desire.259 **/260 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;261 /**262 * Extoll that a particular destination can be communicated with through a particular263 * version of XCM.264 * 265 * - `origin`: Must be Root.266 * - `location`: The destination that is being described.267 * - `xcm_version`: The latest version of XCM that `location` supports.268 **/269 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;270 /**271 * Transfer some assets from the local chain to the sovereign account of a destination chain and forward272 * a notification XCM.273 * 274 * Fee payment on the destination side is made from the first asset listed in the `assets` vector.275 * 276 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.277 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send278 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.279 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be280 * an `AccountId32` value.281 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the282 * `dest` side.283 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay284 * fees.285 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.286 **/287 limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>;288 /**289 * Teleport some assets from the local chain to some destination chain.290 * 291 * Fee payment on the destination side is made from the first asset listed in the `assets` vector.292 * 293 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.294 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send295 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.296 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be297 * an `AccountId32` value.298 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the299 * `dest` side. May not be empty.300 * - `dest_weight`: Equal to the total weight on `dest` of the XCM message301 * `Teleport { assets, effects: [ BuyExecution{..}, DepositAsset{..} ] }`.302 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.303 **/304 limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>;305 /**306 * Transfer some assets from the local chain to the sovereign account of a destination chain and forward307 * a notification XCM.308 * 309 * Fee payment on the destination side is made from the first asset listed in the `assets` vector and310 * fee-weight is calculated locally and thus remote weights are assumed to be equal to311 * local weights.312 * 313 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.314 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send315 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.316 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be317 * an `AccountId32` value.318 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the319 * `dest` side.320 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay321 * fees.322 **/323 reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;324 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;325 /**326 * Teleport some assets from the local chain to some destination chain.327 * 328 * Fee payment on the destination side is made from the first asset listed in the `assets` vector and329 * fee-weight is calculated locally and thus remote weights are assumed to be equal to330 * local weights.331 * 332 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.333 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send334 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.335 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be336 * an `AccountId32` value.337 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the338 * `dest` side. May not be empty.339 * - `dest_weight`: Equal to the total weight on `dest` of the XCM message340 * `Teleport { assets, effects: [ BuyExecution{..}, DepositAsset{..} ] }`.341 **/342 teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;343 /**344 * Generic tx345 **/346 [key: string]: SubmittableExtrinsicFunction<ApiType>;347 };348 sudo: {349 /**350 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo351 * key.352 * 353 * The dispatch origin for this call must be _Signed_.354 * 355 * # <weight>356 * - O(1).357 * - Limited storage reads.358 * - One DB change.359 * # </weight>360 **/361 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;362 /**363 * Authenticates the sudo key and dispatches a function call with `Root` origin.364 * 365 * The dispatch origin for this call must be _Signed_.366 * 367 * # <weight>368 * - O(1).369 * - Limited storage reads.370 * - One DB write (event).371 * - Weight of derivative `call` execution + 10,000.372 * # </weight>373 **/374 sudo: AugmentedSubmittable<(call: Call | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;375 /**376 * Authenticates the sudo key and dispatches a function call with `Signed` origin from377 * a given account.378 * 379 * The dispatch origin for this call must be _Signed_.380 * 381 * # <weight>382 * - O(1).383 * - Limited storage reads.384 * - One DB write (event).385 * - Weight of derivative `call` execution + 10,000.386 * # </weight>387 **/388 sudoAs: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, call: Call | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Call]>;389 /**390 * Authenticates the sudo key and dispatches a function call with `Root` origin.391 * This function does not check the weight of the call, and instead allows the392 * Sudo user to specify the weight of the call.393 * 394 * The dispatch origin for this call must be _Signed_.395 * 396 * # <weight>397 * - O(1).398 * - The weight of this call is defined by the caller.399 * # </weight>400 **/401 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;402 /**403 * Generic tx404 **/405 [key: string]: SubmittableExtrinsicFunction<ApiType>;406 };407 system: {408 /**409 * A dispatch that will fill the block weight up to the given ratio.410 **/411 fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;412 /**413 * Kill all storage items with a key that starts with the given prefix.414 * 415 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under416 * the prefix we are removing to accurately calculate the weight of this function.417 **/418 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;419 /**420 * Kill some items from storage.421 **/422 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;423 /**424 * Make some on-chain remark.425 * 426 * # <weight>427 * - `O(1)`428 * # </weight>429 **/430 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;431 /**432 * Make some on-chain remark and emit event.433 * 434 * # <weight>435 * - `O(b)` where b is the length of the remark.436 * - 1 event.437 * # </weight>438 **/439 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;440 /**441 * Set the new runtime code.442 * 443 * # <weight>444 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`445 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is446 * expensive).447 * - 1 storage write (codec `O(C)`).448 * - 1 digest item.449 * - 1 event.450 * The weight of this function is dependent on the runtime, but generally this is very451 * expensive. We will treat this as a full block.452 * # </weight>453 **/454 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;455 /**456 * Set the new runtime code without doing any checks of the given `code`.457 * 458 * # <weight>459 * - `O(C)` where `C` length of `code`460 * - 1 storage write (codec `O(C)`).461 * - 1 digest item.462 * - 1 event.463 * The weight of this function is dependent on the runtime. We will treat this as a full464 * block. # </weight>465 **/466 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;467 /**468 * Set the number of pages in the WebAssembly environment's heap.469 **/470 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;471 /**472 * Set some items of storage.473 **/474 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;475 /**476 * Generic tx477 **/478 [key: string]: SubmittableExtrinsicFunction<ApiType>;479 };480 timestamp: {481 /**482 * Set the current time.483 * 484 * This call should be invoked exactly once per block. It will panic at the finalization485 * phase, if this call hasn't been invoked by that time.486 * 487 * The timestamp should be greater than the previous one by the amount specified by488 * `MinimumPeriod`.489 * 490 * The dispatch origin for this call must be `Inherent`.491 * 492 * # <weight>493 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)494 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in495 * `on_finalize`)496 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.497 * # </weight>498 **/499 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;500 /**501 * Generic tx502 **/503 [key: string]: SubmittableExtrinsicFunction<ApiType>;504 };505 treasury: {506 /**507 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary508 * and the original deposit will be returned.509 * 510 * May only be called from `T::ApproveOrigin`.511 * 512 * # <weight>513 * - Complexity: O(1).514 * - DbReads: `Proposals`, `Approvals`515 * - DbWrite: `Approvals`516 * # </weight>517 **/518 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;519 /**520 * Put forward a suggestion for spending. A deposit proportional to the value521 * is reserved and slashed if the proposal is rejected. It is returned once the522 * proposal is awarded.523 * 524 * # <weight>525 * - Complexity: O(1)526 * - DbReads: `ProposalCount`, `origin account`527 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`528 * # </weight>529 **/530 proposeSpend: AugmentedSubmittable<(value: Compact<u128> | AnyNumber | Uint8Array, beneficiary: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, MultiAddress]>;531 /**532 * Reject a proposed spend. The original deposit will be slashed.533 * 534 * May only be called from `T::RejectOrigin`.535 * 536 * # <weight>537 * - Complexity: O(1)538 * - DbReads: `Proposals`, `rejected proposer account`539 * - DbWrites: `Proposals`, `rejected proposer account`540 * # </weight>541 **/542 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;543 /**544 * Generic tx545 **/546 [key: string]: SubmittableExtrinsicFunction<ApiType>;547 };548 unique: {549 /**550 * Adds an admin of the Collection.551 * NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.552 * 553 * # Permissions554 * 555 * * Collection Owner.556 * * Collection Admin.557 * 558 * # Arguments559 * 560 * * collection_id: ID of the Collection to add admin for.561 * 562 * * new_admin_id: Address of new admin to add.563 **/564 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;565 /**566 * Add an address to allow list.567 * 568 * # Permissions569 * 570 * * Collection Owner571 * * Collection Admin572 * 573 * # Arguments574 * 575 * * collection_id.576 * 577 * * address.578 **/579 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;580 /**581 * Set, change, or remove approved address to transfer the ownership of the NFT.582 * 583 * # Permissions584 * 585 * * Collection Owner586 * * Collection Admin587 * * Current NFT owner588 * 589 * # Arguments590 * 591 * * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).592 * 593 * * collection_id.594 * 595 * * item_id: ID of the item.596 **/597 approve: AugmentedSubmittable<(spender: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletCommonAccountBasicCrossAccountIdRepr, u32, u32, u128]>;598 /**599 * Destroys a concrete instance of NFT on behalf of the owner600 * See also: [`approve`]601 * 602 * # Permissions603 * 604 * * Collection Owner.605 * * Collection Admin.606 * * Current NFT Owner.607 * 608 * # Arguments609 * 610 * * collection_id: ID of the collection.611 * 612 * * item_id: ID of NFT to burn.613 * 614 * * from: owner of item615 **/616 burnFrom: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, from: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr, u32, u128]>;617 /**618 * Destroys a concrete instance of NFT.619 * 620 * # Permissions621 * 622 * * Collection Owner.623 * * Collection Admin.624 * * Current NFT Owner.625 * 626 * # Arguments627 * 628 * * collection_id: ID of the collection.629 * 630 * * item_id: ID of NFT to burn.631 **/632 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;633 /**634 * Change the owner of the collection.635 * 636 * # Permissions637 * 638 * * Collection Owner.639 * 640 * # Arguments641 * 642 * * collection_id.643 * 644 * * new_owner.645 **/646 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;647 /**648 * # Permissions649 * 650 * * Sponsor.651 * 652 * # Arguments653 * 654 * * collection_id.655 **/656 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;657 /**658 * This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner of the collection is set to the address that signed the transaction and can be changed later.659 * 660 * # Permissions661 * 662 * * Anyone.663 * 664 * # Arguments665 * 666 * * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.667 * 668 * * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.669 * 670 * * token_prefix: UTF-8 string with token prefix.671 * 672 * * mode: [CollectionMode] collection type and type dependent data.673 **/674 createCollection: AugmentedSubmittable<(collectionName: Vec<u16> | (u16 | AnyNumber | Uint8Array)[], collectionDescription: Vec<u16> | (u16 | AnyNumber | Uint8Array)[], tokenPrefix: Bytes | string | Uint8Array, mode: UpDataStructsCollectionMode | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<u16>, Vec<u16>, Bytes, UpDataStructsCollectionMode]>;675 /**676 * This method creates a collection677 * 678 * Prefer it to deprecated [`created_collection`] method679 **/680 createCollectionEx: AugmentedSubmittable<(data: UpDataStructsCreateCollectionData | { mode?: any; access?: any; name?: any; description?: any; tokenPrefix?: any; offchainSchema?: any; schemaVersion?: any; pendingSponsor?: any; limits?: any; variableOnChainSchema?: any; constOnChainSchema?: any; metaUpdatePermission?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [UpDataStructsCreateCollectionData]>;681 /**682 * This method creates a concrete instance of NFT Collection created with CreateCollection method.683 * 684 * # Permissions685 * 686 * * Collection Owner.687 * * Collection Admin.688 * * Anyone if689 * * Allow List is enabled, and690 * * Address is added to allow list, and691 * * MintPermission is enabled (see SetMintPermission method)692 * 693 * # Arguments694 * 695 * * collection_id: ID of the collection.696 * 697 * * owner: Address, initial owner of the NFT.698 * 699 * * data: Token data to store on chain.700 **/701 createItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, owner: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, data: UpDataStructsCreateItemData | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr, UpDataStructsCreateItemData]>;702 /**703 * This method creates multiple items in a collection created with CreateCollection method.704 * 705 * # Permissions706 * 707 * * Collection Owner.708 * * Collection Admin.709 * * Anyone if710 * * Allow List is enabled, and711 * * Address is added to allow list, and712 * * MintPermission is enabled (see SetMintPermission method)713 * 714 * # Arguments715 * 716 * * collection_id: ID of the collection.717 * 718 * * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].719 * 720 * * owner: Address, initial owner of the NFT.721 **/722 createMultipleItems: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, owner: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, itemsData: Vec<UpDataStructsCreateItemData> | (UpDataStructsCreateItemData | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr, Vec<UpDataStructsCreateItemData>]>;723 /**724 * **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.725 * 726 * # Permissions727 * 728 * * Collection Owner.729 * 730 * # Arguments731 * 732 * * collection_id: collection to destroy.733 **/734 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;735 /**736 * Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.737 * 738 * # Permissions739 * 740 * * Collection Owner.741 * * Collection Admin.742 * 743 * # Arguments744 * 745 * * collection_id: ID of the Collection to remove admin for.746 * 747 * * account_id: Address of admin to remove.748 **/749 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;750 /**751 * Switch back to pay-per-own-transaction model.752 * 753 * # Permissions754 * 755 * * Collection owner.756 * 757 * # Arguments758 * 759 * * collection_id.760 **/761 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;762 /**763 * Remove an address from allow list.764 * 765 * # Permissions766 * 767 * * Collection Owner768 * * Collection Admin769 * 770 * # Arguments771 * 772 * * collection_id.773 * 774 * * address.775 **/776 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;777 setCollectionLimits: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newLimit: UpDataStructsCollectionLimits | { accountTokenOwnershipLimit?: any; sponsoredDataSize?: any; sponsoredDataRateLimit?: any; tokenLimit?: any; sponsorTransferTimeout?: any; sponsorApproveTimeout?: any; ownerCanTransfer?: any; ownerCanDestroy?: any; transfersEnabled?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionLimits]>;778 /**779 * # Permissions780 * 781 * * Collection Owner782 * 783 * # Arguments784 * 785 * * collection_id.786 * 787 * * new_sponsor.788 **/789 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;790 /**791 * Set const on-chain data schema.792 * 793 * # Permissions794 * 795 * * Collection Owner796 * * Collection Admin797 * 798 * # Arguments799 * 800 * * collection_id.801 * 802 * * schema: String representing the const on-chain data schema.803 **/804 setConstOnChainSchema: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, schema: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Bytes]>;805 /**806 * Set meta_update_permission value for particular collection807 * 808 * # Permissions809 * 810 * * Collection Owner.811 * 812 * # Arguments813 * 814 * * collection_id: ID of the collection.815 * 816 * * value: New flag value.817 **/818 setMetaUpdatePermissionFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: UpDataStructsMetaUpdatePermission | 'ItemOwner' | 'Admin' | 'None' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsMetaUpdatePermission]>;819 /**820 * Allows Anyone to create tokens if:821 * * Allow List is enabled, and822 * * Address is added to allow list, and823 * * This method was called with True parameter824 * 825 * # Permissions826 * * Collection Owner827 * 828 * # Arguments829 * 830 * * collection_id.831 * 832 * * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.833 **/834 setMintPermission: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, mintPermission: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;835 /**836 * Set off-chain data schema.837 * 838 * # Permissions839 * 840 * * Collection Owner841 * * Collection Admin842 * 843 * # Arguments844 * 845 * * collection_id.846 * 847 * * schema: String representing the offchain data schema.848 **/849 setOffchainSchema: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, schema: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Bytes]>;850 /**851 * Toggle between normal and allow list access for the methods with access for `Anyone`.852 * 853 * # Permissions854 * 855 * * Collection Owner.856 * 857 * # Arguments858 * 859 * * collection_id.860 * 861 * * mode: [AccessMode]862 **/863 setPublicAccessMode: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, mode: UpDataStructsAccessMode | 'Normal' | 'AllowList' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsAccessMode]>;864 /**865 * Set schema standard866 * ImageURL867 * Unique868 * 869 * # Permissions870 * 871 * * Collection Owner872 * * Collection Admin873 * 874 * # Arguments875 * 876 * * collection_id.877 * 878 * * schema: SchemaVersion: enum879 **/880 setSchemaVersion: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, version: UpDataStructsSchemaVersion | 'ImageURL' | 'Unique' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsSchemaVersion]>;881 /**882 * Set transfers_enabled value for particular collection883 * 884 * # Permissions885 * 886 * * Collection Owner.887 * 888 * # Arguments889 * 890 * * collection_id: ID of the collection.891 * 892 * * value: New flag value.893 **/894 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;895 /**896 * Set off-chain data schema.897 * 898 * # Permissions899 * 900 * * Collection Owner901 * * Collection Admin902 * 903 * # Arguments904 * 905 * * collection_id.906 * 907 * * schema: String representing the offchain data schema.908 **/909 setVariableMetaData: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, data: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, Bytes]>;910 /**911 * Set variable on-chain data schema.912 * 913 * # Permissions914 * 915 * * Collection Owner916 * * Collection Admin917 * 918 * # Arguments919 * 920 * * collection_id.921 * 922 * * schema: String representing the variable on-chain data schema.923 **/924 setVariableOnChainSchema: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, schema: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Bytes]>;925 /**926 * Change ownership of the token.927 * 928 * # Permissions929 * 930 * * Collection Owner931 * * Collection Admin932 * * Current NFT owner933 * 934 * # Arguments935 * 936 * * recipient: Address of token recipient.937 * 938 * * collection_id.939 * 940 * * item_id: ID of the item941 * * Non-Fungible Mode: Required.942 * * Fungible Mode: Ignored.943 * * Re-Fungible Mode: Required.944 * 945 * * value: Amount to transfer.946 * * Non-Fungible Mode: Ignored947 * * Fungible Mode: Must specify transferred amount948 * * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)949 **/950 transfer: AugmentedSubmittable<(recipient: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletCommonAccountBasicCrossAccountIdRepr, u32, u32, u128]>;951 /**952 * Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.953 * 954 * # Permissions955 * * Collection Owner956 * * Collection Admin957 * * Current NFT owner958 * * Address approved by current NFT owner959 * 960 * # Arguments961 * 962 * * from: Address that owns token.963 * 964 * * recipient: Address of token recipient.965 * 966 * * collection_id.967 * 968 * * item_id: ID of the item.969 * 970 * * value: Amount to transfer.971 **/972 transferFrom: AugmentedSubmittable<(from: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, recipient: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonAccountBasicCrossAccountIdRepr, u32, u32, u128]>;973 /**974 * Generic tx975 **/976 [key: string]: SubmittableExtrinsicFunction<ApiType>;977 };978 vesting: {979 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;980 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;981 updateVestingSchedules: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, vestingSchedules: Vec<OrmlVestingVestingSchedule> | (OrmlVestingVestingSchedule | { start?: any; period?: any; periodCount?: any; perPeriod?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [MultiAddress, Vec<OrmlVestingVestingSchedule>]>;982 vestedTransfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: OrmlVestingVestingSchedule | { start?: any; period?: any; periodCount?: any; perPeriod?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, OrmlVestingVestingSchedule]>;983 /**984 * Generic tx985 **/986 [key: string]: SubmittableExtrinsicFunction<ApiType>;987 };988 xcmpQueue: {989 /**990 * Generic tx991 **/992 [key: string]: SubmittableExtrinsicFunction<ApiType>;993 };994 }995996 export interface SubmittableExtrinsics<ApiType extends ApiTypes> extends AugmentedSubmittables<ApiType> {997 (extrinsic: Call | Extrinsic | Uint8Array | string): SubmittableExtrinsic<ApiType>;998 [key: string]: SubmittableModuleExtrinsics<ApiType>;999 }1000}difftreelog
source
tests/src/interfaces/augment-api-tx.ts50.0 KiBsourcehistory