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/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, Call, H160, H256, MultiAddress, Perbill } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1314export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;15export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;16export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1718declare module '@polkadot/api-base/types/submittable' {19 interface AugmentedSubmittables<ApiType extends ApiTypes> {20 balances: {21 /**22 * Exactly as `transfer`, except the origin must be root and the source account may be23 * specified.24 * # <weight>25 * - Same as transfer, but additional read and write because the source account is not26 * assumed to be in the overlay.27 * # </weight>28 **/29 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>]>;30 /**31 * Unreserve some balance from a user by force.32 * 33 * Can only be called by ROOT.34 **/35 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;36 /**37 * Set the balances of a given account.38 * 39 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will40 * also alter the total issuance of the system (`TotalIssuance`) appropriately.41 * If the new free or reserved balance is below the existential deposit,42 * it will reset the account nonce (`frame_system::AccountNonce`).43 * 44 * The dispatch origin for this call is `root`.45 **/46 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>]>;47 /**48 * Transfer some liquid free balance to another account.49 * 50 * `transfer` will set the `FreeBalance` of the sender and receiver.51 * If the sender's account is below the existential deposit as a result52 * of the transfer, the account will be reaped.53 * 54 * The dispatch origin for this call must be `Signed` by the transactor.55 * 56 * # <weight>57 * - Dependent on arguments but not critical, given proper implementations for input config58 * types. See related functions below.59 * - It contains a limited number of reads and writes internally and no complex60 * computation.61 * 62 * Related functions:63 * 64 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.65 * - Transferring balances to accounts that did not exist before will cause66 * `T::OnNewAccount::on_new_account` to be called.67 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.68 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check69 * that the transfer will not kill the origin account.70 * ---------------------------------71 * - Origin account is already in memory, so no DB operations for them.72 * # </weight>73 **/74 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>]>;75 /**76 * Transfer the entire transferable balance from the caller account.77 * 78 * NOTE: This function only attempts to transfer _transferable_ balances. This means that79 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be80 * transferred by this function. To ensure that this function results in a killed account,81 * you might need to prepare the account by removing any reference counters, storage82 * deposits, etc...83 * 84 * The dispatch origin of this call must be Signed.85 * 86 * - `dest`: The recipient of the transfer.87 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all88 * of the funds the account has, causing the sender account to be killed (false), or89 * transfer everything except at least the existential deposit, which will guarantee to90 * keep the sender account alive (true). # <weight>91 * - O(1). Just like transfer, but reading the user's transferable balance first.92 * #</weight>93 **/94 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;95 /**96 * Same as the [`transfer`] call, but with a check that the transfer will not kill the97 * origin account.98 * 99 * 99% of the time you want [`transfer`] instead.100 * 101 * [`transfer`]: struct.Pallet.html#method.transfer102 **/103 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>]>;104 /**105 * Generic tx106 **/107 [key: string]: SubmittableExtrinsicFunction<ApiType>;108 };109 charging: {110 /**111 * Generic tx112 **/113 [key: string]: SubmittableExtrinsicFunction<ApiType>;114 };115 configuration: {116 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;117 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;118 /**119 * Generic tx120 **/121 [key: string]: SubmittableExtrinsicFunction<ApiType>;122 };123 cumulusXcm: {124 /**125 * Generic tx126 **/127 [key: string]: SubmittableExtrinsicFunction<ApiType>;128 };129 dmpQueue: {130 /**131 * Service a single overweight message.132 * 133 * - `origin`: Must pass `ExecuteOverweightOrigin`.134 * - `index`: The index of the overweight message to service.135 * - `weight_limit`: The amount of weight that message execution may take.136 * 137 * Errors:138 * - `Unknown`: Message of `index` is unknown.139 * - `OverLimit`: Message execution may use greater than `weight_limit`.140 * 141 * Events:142 * - `OverweightServiced`: On success.143 **/144 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;145 /**146 * Generic tx147 **/148 [key: string]: SubmittableExtrinsicFunction<ApiType>;149 };150 ethereum: {151 /**152 * Transact an Ethereum transaction.153 **/154 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;155 /**156 * Generic tx157 **/158 [key: string]: SubmittableExtrinsicFunction<ApiType>;159 };160 evm: {161 /**162 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.163 **/164 call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;165 /**166 * Issue an EVM create operation. This is similar to a contract creation transaction in167 * Ethereum.168 **/169 create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;170 /**171 * Issue an EVM create2 operation.172 **/173 create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, maxFeePerGas: U256 | AnyNumber | Uint8Array, maxPriorityFeePerGas: Option<U256> | null | Uint8Array | U256 | AnyNumber, nonce: Option<U256> | null | Uint8Array | U256 | AnyNumber, accessList: Vec<ITuple<[H160, Vec<H256>]>> | ([H160 | string | Uint8Array, Vec<H256> | (H256 | string | Uint8Array)[]])[]) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>, Option<U256>, Vec<ITuple<[H160, Vec<H256>]>>]>;174 /**175 * Withdraw balance from EVM into currency/balances pallet.176 **/177 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;178 /**179 * Generic tx180 **/181 [key: string]: SubmittableExtrinsicFunction<ApiType>;182 };183 evmMigration: {184 /**185 * Start contract migration, inserts contract stub at target address,186 * and marks account as pending, allowing to insert storage187 **/188 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;189 /**190 * Finish contract migration, allows it to be called.191 * It is not possible to alter contract storage via [`Self::set_data`]192 * after this call.193 **/194 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;195 /**196 * Insert items into contract storage, this method can be called197 * multiple times198 **/199 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;200 /**201 * Generic tx202 **/203 [key: string]: SubmittableExtrinsicFunction<ApiType>;204 };205 inflation: {206 /**207 * This method sets the inflation start date. Can be only called once.208 * Inflation start block can be backdated and will catch up. The method will create Treasury209 * account if it does not exist and perform the first inflation deposit.210 * 211 * # Permissions212 * 213 * * Root214 * 215 * # Arguments216 * 217 * * inflation_start_relay_block: The relay chain block at which inflation should start218 **/219 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;220 /**221 * Generic tx222 **/223 [key: string]: SubmittableExtrinsicFunction<ApiType>;224 };225 parachainSystem: {226 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;227 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;228 /**229 * Set the current validation data.230 * 231 * This should be invoked exactly once per block. It will panic at the finalization232 * phase if the call was not invoked.233 * 234 * The dispatch origin for this call must be `Inherent`235 * 236 * As a side effect, this function upgrades the current validation function237 * if the appropriate time has come.238 **/239 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;240 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;241 /**242 * Generic tx243 **/244 [key: string]: SubmittableExtrinsicFunction<ApiType>;245 };246 polkadotXcm: {247 /**248 * Execute an XCM message from a local, signed, origin.249 * 250 * An event is deposited indicating whether `msg` could be executed completely or only251 * partially.252 * 253 * No more than `max_weight` will be used in its attempted execution. If this is less than the254 * maximum amount of weight that the message could take to be executed, then no execution255 * attempt will be made.256 * 257 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully258 * to completion; only that *some* of it was executed.259 **/260 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;261 /**262 * Set a safe XCM version (the version that XCM should be encoded with if the most recent263 * version a destination can accept is unknown).264 * 265 * - `origin`: Must be Root.266 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.267 **/268 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;269 /**270 * Ask a location to notify us regarding their XCM version and any changes to it.271 * 272 * - `origin`: Must be Root.273 * - `location`: The location to which we should subscribe for XCM version notifications.274 **/275 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;276 /**277 * Require that a particular destination should no longer notify us regarding any XCM278 * version changes.279 * 280 * - `origin`: Must be Root.281 * - `location`: The location to which we are currently subscribed for XCM version282 * notifications which we no longer desire.283 **/284 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;285 /**286 * Extoll that a particular destination can be communicated with through a particular287 * version of XCM.288 * 289 * - `origin`: Must be Root.290 * - `location`: The destination that is being described.291 * - `xcm_version`: The latest version of XCM that `location` supports.292 **/293 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;294 /**295 * Transfer some assets from the local chain to the sovereign account of a destination296 * chain and forward a notification XCM.297 * 298 * Fee payment on the destination side is made from the asset in the `assets` vector of299 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight300 * is needed than `weight_limit`, then the operation will fail and the assets send may be301 * at risk.302 * 303 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.304 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send305 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.306 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be307 * an `AccountId32` value.308 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the309 * `dest` side.310 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay311 * fees.312 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.313 **/314 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]>;315 /**316 * Teleport some assets from the local chain to some destination chain.317 * 318 * Fee payment on the destination side is made from the asset in the `assets` vector of319 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight320 * is needed than `weight_limit`, then the operation will fail and the assets send may be321 * at risk.322 * 323 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.324 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send325 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.326 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be327 * an `AccountId32` value.328 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the329 * `dest` side. May not be empty.330 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay331 * fees.332 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.333 **/334 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]>;335 /**336 * Transfer some assets from the local chain to the sovereign account of a destination337 * chain and forward a notification XCM.338 * 339 * Fee payment on the destination side is made from the asset in the `assets` vector of340 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,341 * with all fees taken as needed from the asset.342 * 343 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.344 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send345 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.346 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be347 * an `AccountId32` value.348 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the349 * `dest` side.350 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay351 * fees.352 **/353 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]>;354 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;355 /**356 * Teleport some assets from the local chain to some destination chain.357 * 358 * Fee payment on the destination side is made from the asset in the `assets` vector of359 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,360 * with all fees taken as needed from the asset.361 * 362 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.363 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send364 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.365 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be366 * an `AccountId32` value.367 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the368 * `dest` side. May not be empty.369 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay370 * fees.371 **/372 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]>;373 /**374 * Generic tx375 **/376 [key: string]: SubmittableExtrinsicFunction<ApiType>;377 };378 structure: {379 /**380 * Generic tx381 **/382 [key: string]: SubmittableExtrinsicFunction<ApiType>;383 };384 sudo: {385 /**386 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo387 * key.388 * 389 * The dispatch origin for this call must be _Signed_.390 * 391 * # <weight>392 * - O(1).393 * - Limited storage reads.394 * - One DB change.395 * # </weight>396 **/397 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;398 /**399 * Authenticates the sudo key and dispatches a function call with `Root` origin.400 * 401 * The dispatch origin for this call must be _Signed_.402 * 403 * # <weight>404 * - O(1).405 * - Limited storage reads.406 * - One DB write (event).407 * - Weight of derivative `call` execution + 10,000.408 * # </weight>409 **/410 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;411 /**412 * Authenticates the sudo key and dispatches a function call with `Signed` origin from413 * a given account.414 * 415 * The dispatch origin for this call must be _Signed_.416 * 417 * # <weight>418 * - O(1).419 * - Limited storage reads.420 * - One DB write (event).421 * - Weight of derivative `call` execution + 10,000.422 * # </weight>423 **/424 sudoAs: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Call]>;425 /**426 * Authenticates the sudo key and dispatches a function call with `Root` origin.427 * This function does not check the weight of the call, and instead allows the428 * Sudo user to specify the weight of the call.429 * 430 * The dispatch origin for this call must be _Signed_.431 * 432 * # <weight>433 * - O(1).434 * - The weight of this call is defined by the caller.435 * # </weight>436 **/437 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;438 /**439 * Generic tx440 **/441 [key: string]: SubmittableExtrinsicFunction<ApiType>;442 };443 system: {444 /**445 * A dispatch that will fill the block weight up to the given ratio.446 **/447 fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;448 /**449 * Kill all storage items with a key that starts with the given prefix.450 * 451 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under452 * the prefix we are removing to accurately calculate the weight of this function.453 **/454 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;455 /**456 * Kill some items from storage.457 **/458 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;459 /**460 * Make some on-chain remark.461 * 462 * # <weight>463 * - `O(1)`464 * # </weight>465 **/466 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;467 /**468 * Make some on-chain remark and emit event.469 **/470 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;471 /**472 * Set the new runtime code.473 * 474 * # <weight>475 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`476 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is477 * expensive).478 * - 1 storage write (codec `O(C)`).479 * - 1 digest item.480 * - 1 event.481 * The weight of this function is dependent on the runtime, but generally this is very482 * expensive. We will treat this as a full block.483 * # </weight>484 **/485 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;486 /**487 * Set the new runtime code without doing any checks of the given `code`.488 * 489 * # <weight>490 * - `O(C)` where `C` length of `code`491 * - 1 storage write (codec `O(C)`).492 * - 1 digest item.493 * - 1 event.494 * The weight of this function is dependent on the runtime. We will treat this as a full495 * block. # </weight>496 **/497 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;498 /**499 * Set the number of pages in the WebAssembly environment's heap.500 **/501 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;502 /**503 * Set some items of storage.504 **/505 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;506 /**507 * Generic tx508 **/509 [key: string]: SubmittableExtrinsicFunction<ApiType>;510 };511 timestamp: {512 /**513 * Set the current time.514 * 515 * This call should be invoked exactly once per block. It will panic at the finalization516 * phase, if this call hasn't been invoked by that time.517 * 518 * The timestamp should be greater than the previous one by the amount specified by519 * `MinimumPeriod`.520 * 521 * The dispatch origin for this call must be `Inherent`.522 * 523 * # <weight>524 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)525 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in526 * `on_finalize`)527 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.528 * # </weight>529 **/530 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;531 /**532 * Generic tx533 **/534 [key: string]: SubmittableExtrinsicFunction<ApiType>;535 };536 tokens: {537 /**538 * Exactly as `transfer`, except the origin must be root and the source539 * account may be specified.540 * 541 * The dispatch origin for this call must be _Root_.542 * 543 * - `source`: The sender of the transfer.544 * - `dest`: The recipient of the transfer.545 * - `currency_id`: currency type.546 * - `amount`: free balance amount to tranfer.547 **/548 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, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;549 /**550 * Set the balances of a given account.551 * 552 * This will alter `FreeBalance` and `ReservedBalance` in storage. it553 * will also decrease the total issuance of the system554 * (`TotalIssuance`). If the new free or reserved balance is below the555 * existential deposit, it will reap the `AccountInfo`.556 * 557 * The dispatch origin for this call is `root`.558 **/559 setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>, Compact<u128>]>;560 /**561 * Transfer some liquid free balance to another account.562 * 563 * `transfer` will set the `FreeBalance` of the sender and receiver.564 * It will decrease the total issuance of the system by the565 * `TransferFee`. If the sender's account is below the existential566 * deposit as a result of the transfer, the account will be reaped.567 * 568 * The dispatch origin for this call must be `Signed` by the569 * transactor.570 * 571 * - `dest`: The recipient of the transfer.572 * - `currency_id`: currency type.573 * - `amount`: free balance amount to tranfer.574 **/575 transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;576 /**577 * Transfer all remaining balance to the given account.578 * 579 * NOTE: This function only attempts to transfer _transferable_580 * balances. This means that any locked, reserved, or existential581 * deposits (when `keep_alive` is `true`), will not be transferred by582 * this function. To ensure that this function results in a killed583 * account, you might need to prepare the account by removing any584 * reference counters, storage deposits, etc...585 * 586 * The dispatch origin for this call must be `Signed` by the587 * transactor.588 * 589 * - `dest`: The recipient of the transfer.590 * - `currency_id`: currency type.591 * - `keep_alive`: A boolean to determine if the `transfer_all`592 * operation should send all of the funds the account has, causing593 * the sender account to be killed (false), or transfer everything594 * except at least the existential deposit, which will guarantee to595 * keep the sender account alive (true).596 **/597 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, bool]>;598 /**599 * Same as the [`transfer`] call, but with a check that the transfer600 * will not kill the origin account.601 * 602 * 99% of the time you want [`transfer`] instead.603 * 604 * The dispatch origin for this call must be `Signed` by the605 * transactor.606 * 607 * - `dest`: The recipient of the transfer.608 * - `currency_id`: currency type.609 * - `amount`: free balance amount to tranfer.610 **/611 transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletForeignAssetsAssetIds, Compact<u128>]>;612 /**613 * Generic tx614 **/615 [key: string]: SubmittableExtrinsicFunction<ApiType>;616 };617 treasury: {618 /**619 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary620 * and the original deposit will be returned.621 * 622 * May only be called from `T::ApproveOrigin`.623 * 624 * # <weight>625 * - Complexity: O(1).626 * - DbReads: `Proposals`, `Approvals`627 * - DbWrite: `Approvals`628 * # </weight>629 **/630 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;631 /**632 * Put forward a suggestion for spending. A deposit proportional to the value633 * is reserved and slashed if the proposal is rejected. It is returned once the634 * proposal is awarded.635 * 636 * # <weight>637 * - Complexity: O(1)638 * - DbReads: `ProposalCount`, `origin account`639 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`640 * # </weight>641 **/642 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]>;643 /**644 * Reject a proposed spend. The original deposit will be slashed.645 * 646 * May only be called from `T::RejectOrigin`.647 * 648 * # <weight>649 * - Complexity: O(1)650 * - DbReads: `Proposals`, `rejected proposer account`651 * - DbWrites: `Proposals`, `rejected proposer account`652 * # </weight>653 **/654 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;655 /**656 * Force a previously approved proposal to be removed from the approval queue.657 * The original deposit will no longer be returned.658 * 659 * May only be called from `T::RejectOrigin`.660 * - `proposal_id`: The index of a proposal661 * 662 * # <weight>663 * - Complexity: O(A) where `A` is the number of approvals664 * - Db reads and writes: `Approvals`665 * # </weight>666 * 667 * Errors:668 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,669 * i.e., the proposal has not been approved. This could also mean the proposal does not670 * exist altogether, thus there is no way it would have been approved in the first place.671 **/672 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;673 /**674 * Propose and approve a spend of treasury funds.675 * 676 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.677 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.678 * - `beneficiary`: The destination account for the transfer.679 * 680 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the681 * beneficiary.682 **/683 spend: AugmentedSubmittable<(amount: Compact<u128> | AnyNumber | Uint8Array, beneficiary: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u128>, MultiAddress]>;684 /**685 * Generic tx686 **/687 [key: string]: SubmittableExtrinsicFunction<ApiType>;688 };689 unique: {690 /**691 * Add an admin to a collection.692 * 693 * NFT Collection can be controlled by multiple admin addresses694 * (some which can also be servers, for example). Admins can issue695 * and burn NFTs, as well as add and remove other admins,696 * but cannot change NFT or Collection ownership.697 * 698 * # Permissions699 * 700 * * Collection owner701 * * Collection admin702 * 703 * # Arguments704 * 705 * * `collection_id`: ID of the Collection to add an admin for.706 * * `new_admin`: Address of new admin to add.707 **/708 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;709 /**710 * Add an address to allow list.711 * 712 * # Permissions713 * 714 * * Collection owner715 * * Collection admin716 * 717 * # Arguments718 * 719 * * `collection_id`: ID of the modified collection.720 * * `address`: ID of the address to be added to the allowlist.721 **/722 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;723 /**724 * Allow a non-permissioned address to transfer or burn an item.725 * 726 * # Permissions727 * 728 * * Collection owner729 * * Collection admin730 * * Current item owner731 * 732 * # Arguments733 * 734 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.735 * * `collection_id`: ID of the collection the item belongs to.736 * * `item_id`: ID of the item transactions on which are now approved.737 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).738 * Set to 0 to revoke the approval.739 **/740 approve: AugmentedSubmittable<(spender: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>;741 /**742 * Destroy a token on behalf of the owner as a non-owner account.743 * 744 * See also: [`approve`][`Pallet::approve`].745 * 746 * After this method executes, one approval is removed from the total so that747 * the approved address will not be able to transfer this item again from this owner.748 * 749 * # Permissions750 * 751 * * Collection owner752 * * Collection admin753 * * Current token owner754 * * Address approved by current item owner755 * 756 * # Arguments757 * 758 * * `from`: The owner of the burning item.759 * * `collection_id`: ID of the collection to which the item belongs.760 * * `item_id`: ID of item to burn.761 * * `value`: Number of pieces to burn.762 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.763 * * Fungible Mode: The desired number of pieces to burn.764 * * Re-Fungible Mode: The desired number of pieces to burn.765 **/766 burnFrom: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, from: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, u32, u128]>;767 /**768 * Destroy an item.769 * 770 * # Permissions771 * 772 * * Collection owner773 * * Collection admin774 * * Current item owner775 * 776 * # Arguments777 * 778 * * `collection_id`: ID of the collection to which the item belongs.779 * * `item_id`: ID of item to burn.780 * * `value`: Number of pieces of the item to destroy.781 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.782 * * Fungible Mode: The desired number of pieces to burn.783 * * Re-Fungible Mode: The desired number of pieces to burn.784 **/785 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;786 /**787 * Change the owner of the collection.788 * 789 * # Permissions790 * 791 * * Collection owner792 * 793 * # Arguments794 * 795 * * `collection_id`: ID of the modified collection.796 * * `new_owner`: ID of the account that will become the owner.797 **/798 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;799 /**800 * Confirm own sponsorship of a collection, becoming the sponsor.801 * 802 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].803 * Sponsor can pay the fees of a transaction instead of the sender,804 * but only within specified limits.805 * 806 * # Permissions807 * 808 * * Sponsor-to-be809 * 810 * # Arguments811 * 812 * * `collection_id`: ID of the collection with the pending sponsor.813 **/814 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;815 /**816 * Create a collection of tokens.817 * 818 * Each Token may have multiple properties encoded as an array of bytes819 * of certain length. The initial owner of the collection is set820 * to the address that signed the transaction and can be changed later.821 * 822 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.823 * 824 * # Permissions825 * 826 * * Anyone - becomes the owner of the new collection.827 * 828 * # Arguments829 * 830 * * `collection_name`: Wide-character string with collection name831 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).832 * * `collection_description`: Wide-character string with collection description833 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).834 * * `token_prefix`: Byte string containing the token prefix to mark a collection835 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).836 * * `mode`: Type of items stored in the collection and type dependent data.837 **/838 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]>;839 /**840 * Create a collection with explicit parameters.841 * 842 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.843 * 844 * # Permissions845 * 846 * * Anyone - becomes the owner of the new collection.847 * 848 * # Arguments849 * 850 * * `data`: Explicit data of a collection used for its creation.851 **/852 createCollectionEx: AugmentedSubmittable<(data: UpDataStructsCreateCollectionData | { mode?: any; access?: any; name?: any; description?: any; tokenPrefix?: any; pendingSponsor?: any; limits?: any; permissions?: any; tokenPropertyPermissions?: any; properties?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [UpDataStructsCreateCollectionData]>;853 /**854 * Mint an item within a collection.855 * 856 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].857 * 858 * # Permissions859 * 860 * * Collection owner861 * * Collection admin862 * * Anyone if863 * * Allow List is enabled, and864 * * Address is added to allow list, and865 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])866 * 867 * # Arguments868 * 869 * * `collection_id`: ID of the collection to which an item would belong.870 * * `owner`: Address of the initial owner of the item.871 * * `data`: Token data describing the item to store on chain.872 **/873 createItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, owner: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, data: UpDataStructsCreateItemData | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, UpDataStructsCreateItemData]>;874 /**875 * Create multiple items within a collection.876 * 877 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].878 * 879 * # Permissions880 * 881 * * Collection owner882 * * Collection admin883 * * Anyone if884 * * Allow List is enabled, and885 * * Address is added to the allow list, and886 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])887 * 888 * # Arguments889 * 890 * * `collection_id`: ID of the collection to which the tokens would belong.891 * * `owner`: Address of the initial owner of the tokens.892 * * `items_data`: Vector of data describing each item to be created.893 **/894 createMultipleItems: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, owner: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, itemsData: Vec<UpDataStructsCreateItemData> | (UpDataStructsCreateItemData | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, Vec<UpDataStructsCreateItemData>]>;895 /**896 * Create multiple items within a collection with explicitly specified initial parameters.897 * 898 * # Permissions899 * 900 * * Collection owner901 * * Collection admin902 * * Anyone if903 * * Allow List is enabled, and904 * * Address is added to allow list, and905 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])906 * 907 * # Arguments908 * 909 * * `collection_id`: ID of the collection to which the tokens would belong.910 * * `data`: Explicit item creation data.911 **/912 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;913 /**914 * Delete specified collection properties.915 * 916 * # Permissions917 * 918 * * Collection Owner919 * * Collection Admin920 * 921 * # Arguments922 * 923 * * `collection_id`: ID of the modified collection.924 * * `property_keys`: Vector of keys of the properties to be deleted.925 * Keys support Latin letters, `-`, `_`, and `.` as symbols.926 **/927 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;928 /**929 * Delete specified token properties. Currently properties only work with NFTs.930 * 931 * # Permissions932 * 933 * * Depends on collection's token property permissions and specified property mutability:934 * * Collection owner935 * * Collection admin936 * * Token owner937 * 938 * # Arguments939 * 940 * * `collection_id`: ID of the collection to which the token belongs.941 * * `token_id`: ID of the modified token.942 * * `property_keys`: Vector of keys of the properties to be deleted.943 * Keys support Latin letters, `-`, `_`, and `.` as symbols.944 **/945 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;946 /**947 * Destroy a collection if no tokens exist within.948 * 949 * # Permissions950 * 951 * * Collection owner952 * 953 * # Arguments954 * 955 * * `collection_id`: Collection to destroy.956 **/957 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;958 /**959 * Remove admin of a collection.960 * 961 * An admin address can remove itself. List of admins may become empty,962 * in which case only Collection Owner will be able to add an Admin.963 * 964 * # Permissions965 * 966 * * Collection owner967 * * Collection admin968 * 969 * # Arguments970 * 971 * * `collection_id`: ID of the collection to remove the admin for.972 * * `account_id`: Address of the admin to remove.973 **/974 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;975 /**976 * Remove a collection's a sponsor, making everyone pay for their own transactions.977 * 978 * # Permissions979 * 980 * * Collection owner981 * 982 * # Arguments983 * 984 * * `collection_id`: ID of the collection with the sponsor to remove.985 **/986 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;987 /**988 * Remove an address from allow list.989 * 990 * # Permissions991 * 992 * * Collection owner993 * * Collection admin994 * 995 * # Arguments996 * 997 * * `collection_id`: ID of the modified collection.998 * * `address`: ID of the address to be removed from the allowlist.999 **/1000 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1001 /**1002 * Re-partition a refungible token, while owning all of its parts/pieces.1003 * 1004 * # Permissions1005 * 1006 * * Token owner (must own every part)1007 * 1008 * # Arguments1009 * 1010 * * `collection_id`: ID of the collection the RFT belongs to.1011 * * `token_id`: ID of the RFT.1012 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1013 **/1014 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1015 /**1016 * Set specific limits of a collection. Empty, or None fields mean chain default.1017 * 1018 * # Permissions1019 * 1020 * * Collection owner1021 * * Collection admin1022 * 1023 * # Arguments1024 * 1025 * * `collection_id`: ID of the modified collection.1026 * * `new_limit`: New limits of the collection. Fields that are not set (None)1027 * will not overwrite the old ones.1028 **/1029 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]>;1030 /**1031 * Set specific permissions of a collection. Empty, or None fields mean chain default.1032 * 1033 * # Permissions1034 * 1035 * * Collection owner1036 * * Collection admin1037 * 1038 * # Arguments1039 * 1040 * * `collection_id`: ID of the modified collection.1041 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1042 * will not overwrite the old ones.1043 **/1044 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1045 /**1046 * Add or change collection properties.1047 * 1048 * # Permissions1049 * 1050 * * Collection owner1051 * * Collection admin1052 * 1053 * # Arguments1054 * 1055 * * `collection_id`: ID of the modified collection.1056 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1057 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1058 **/1059 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1060 /**1061 * Set (invite) a new collection sponsor.1062 * 1063 * If successful, confirmation from the sponsor-to-be will be pending.1064 * 1065 * # Permissions1066 * 1067 * * Collection owner1068 * * Collection admin1069 * 1070 * # Arguments1071 * 1072 * * `collection_id`: ID of the modified collection.1073 * * `new_sponsor`: ID of the account of the sponsor-to-be.1074 **/1075 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1076 /**1077 * Add or change token properties according to collection's permissions.1078 * Currently properties only work with NFTs.1079 * 1080 * # Permissions1081 * 1082 * * Depends on collection's token property permissions and specified property mutability:1083 * * Collection owner1084 * * Collection admin1085 * * Token owner1086 * 1087 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1088 * 1089 * # Arguments1090 * 1091 * * `collection_id: ID of the collection to which the token belongs.1092 * * `token_id`: ID of the modified token.1093 * * `properties`: Vector of key-value pairs stored as the token's metadata.1094 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1095 **/1096 setTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<UpDataStructsProperty>]>;1097 /**1098 * Add or change token property permissions of a collection.1099 * 1100 * Without a permission for a particular key, a property with that key1101 * cannot be created in a token.1102 * 1103 * # Permissions1104 * 1105 * * Collection owner1106 * * Collection admin1107 * 1108 * # Arguments1109 * 1110 * * `collection_id`: ID of the modified collection.1111 * * `property_permissions`: Vector of permissions for property keys.1112 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1113 **/1114 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1115 /**1116 * Completely allow or disallow transfers for a particular collection.1117 * 1118 * # Permissions1119 * 1120 * * Collection owner1121 * 1122 * # Arguments1123 * 1124 * * `collection_id`: ID of the collection.1125 * * `value`: New value of the flag, are transfers allowed?1126 **/1127 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1128 /**1129 * Change ownership of the token.1130 * 1131 * # Permissions1132 * 1133 * * Collection owner1134 * * Collection admin1135 * * Current token owner1136 * 1137 * # Arguments1138 * 1139 * * `recipient`: Address of token recipient.1140 * * `collection_id`: ID of the collection the item belongs to.1141 * * `item_id`: ID of the item.1142 * * Non-Fungible Mode: Required.1143 * * Fungible Mode: Ignored.1144 * * Re-Fungible Mode: Required.1145 * 1146 * * `value`: Amount to transfer.1147 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1148 * * Fungible Mode: The desired number of pieces to transfer.1149 * * Re-Fungible Mode: The desired number of pieces to transfer.1150 **/1151 transfer: AugmentedSubmittable<(recipient: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>;1152 /**1153 * Change ownership of an item on behalf of the owner as a non-owner account.1154 * 1155 * See the [`approve`][`Pallet::approve`] method for additional information.1156 * 1157 * After this method executes, one approval is removed from the total so that1158 * the approved address will not be able to transfer this item again from this owner.1159 * 1160 * # Permissions1161 * 1162 * * Collection owner1163 * * Collection admin1164 * * Current item owner1165 * * Address approved by current item owner1166 * 1167 * # Arguments1168 * 1169 * * `from`: Address that currently owns the token.1170 * * `recipient`: Address of the new token-owner-to-be.1171 * * `collection_id`: ID of the collection the item.1172 * * `item_id`: ID of the item to be transferred.1173 * * `value`: Amount to transfer.1174 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1175 * * Fungible Mode: The desired number of pieces to transfer.1176 * * Re-Fungible Mode: The desired number of pieces to transfer.1177 **/1178 transferFrom: AugmentedSubmittable<(from: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, recipient: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>;1179 /**1180 * Generic tx1181 **/1182 [key: string]: SubmittableExtrinsicFunction<ApiType>;1183 };1184 vesting: {1185 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1186 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1187 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>]>;1188 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]>;1189 /**1190 * Generic tx1191 **/1192 [key: string]: SubmittableExtrinsicFunction<ApiType>;1193 };1194 xcmpQueue: {1195 /**1196 * Resumes all XCM executions for the XCMP queue.1197 * 1198 * Note that this function doesn't change the status of the in/out bound channels.1199 * 1200 * - `origin`: Must pass `ControllerOrigin`.1201 **/1202 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1203 /**1204 * Services a single overweight XCM.1205 * 1206 * - `origin`: Must pass `ExecuteOverweightOrigin`.1207 * - `index`: The index of the overweight XCM to service1208 * - `weight_limit`: The amount of weight that XCM execution may take.1209 * 1210 * Errors:1211 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1212 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1213 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1214 * 1215 * Events:1216 * - `OverweightServiced`: On success.1217 **/1218 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1219 /**1220 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1221 * 1222 * - `origin`: Must pass `ControllerOrigin`.1223 **/1224 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1225 /**1226 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1227 * messages from the channel.1228 * 1229 * - `origin`: Must pass `Root`.1230 * - `new`: Desired value for `QueueConfigData.drop_threshold`1231 **/1232 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1233 /**1234 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1235 * message sending may recommence after it has been suspended.1236 * 1237 * - `origin`: Must pass `Root`.1238 * - `new`: Desired value for `QueueConfigData.resume_threshold`1239 **/1240 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1241 /**1242 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1243 * suspend their sending.1244 * 1245 * - `origin`: Must pass `Root`.1246 * - `new`: Desired value for `QueueConfigData.suspend_value`1247 **/1248 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1249 /**1250 * Overwrites the amount of remaining weight under which we stop processing messages.1251 * 1252 * - `origin`: Must pass `Root`.1253 * - `new`: Desired value for `QueueConfigData.threshold_weight`1254 **/1255 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1256 /**1257 * Overwrites the speed to which the available weight approaches the maximum weight.1258 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1259 * 1260 * - `origin`: Must pass `Root`.1261 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1262 **/1263 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1264 /**1265 * Overwrite the maximum amount of weight any individual message may consume.1266 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1267 * 1268 * - `origin`: Must pass `Root`.1269 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1270 **/1271 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1272 /**1273 * Generic tx1274 **/1275 [key: string]: SubmittableExtrinsicFunction<ApiType>;1276 };1277 xTokens: {1278 /**1279 * Transfer native currencies.1280 * 1281 * `dest_weight` is the weight for XCM execution on the dest chain, and1282 * it would be charged from the transferred assets. If set below1283 * requirements, the execution may fail and assets wouldn't be1284 * received.1285 * 1286 * It's a no-op if any error on local XCM execution or message sending.1287 * Note sending assets out per se doesn't guarantee they would be1288 * received. Receiving depends on if the XCM message could be delivered1289 * by the network, and if the receiving chain would handle1290 * messages correctly.1291 **/1292 transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, u64]>;1293 /**1294 * Transfer `MultiAsset`.1295 * 1296 * `dest_weight` is the weight for XCM execution on the dest chain, and1297 * it would be charged from the transferred assets. If set below1298 * requirements, the execution may fail and assets wouldn't be1299 * received.1300 * 1301 * It's a no-op if any error on local XCM execution or message sending.1302 * Note sending assets out per se doesn't guarantee they would be1303 * received. Receiving depends on if the XCM message could be delivered1304 * by the network, and if the receiving chain would handle1305 * messages correctly.1306 **/1307 transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, u64]>;1308 /**1309 * Transfer several `MultiAsset` specifying the item to be used as fee1310 * 1311 * `dest_weight` is the weight for XCM execution on the dest chain, and1312 * it would be charged from the transferred assets. If set below1313 * requirements, the execution may fail and assets wouldn't be1314 * received.1315 * 1316 * `fee_item` is index of the MultiAssets that we want to use for1317 * payment1318 * 1319 * It's a no-op if any error on local XCM execution or message sending.1320 * Note sending assets out per se doesn't guarantee they would be1321 * received. Receiving depends on if the XCM message could be delivered1322 * by the network, and if the receiving chain would handle1323 * messages correctly.1324 **/1325 transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, u64]>;1326 /**1327 * Transfer `MultiAsset` specifying the fee and amount as separate.1328 * 1329 * `dest_weight` is the weight for XCM execution on the dest chain, and1330 * it would be charged from the transferred assets. If set below1331 * requirements, the execution may fail and assets wouldn't be1332 * received.1333 * 1334 * `fee` is the multiasset to be spent to pay for execution in1335 * destination chain. Both fee and amount will be subtracted form the1336 * callers balance For now we only accept fee and asset having the same1337 * `MultiLocation` id.1338 * 1339 * If `fee` is not high enough to cover for the execution costs in the1340 * destination chain, then the assets will be trapped in the1341 * destination chain1342 * 1343 * It's a no-op if any error on local XCM execution or message sending.1344 * Note sending assets out per se doesn't guarantee they would be1345 * received. Receiving depends on if the XCM message could be delivered1346 * by the network, and if the receiving chain would handle1347 * messages correctly.1348 **/1349 transferMultiassetWithFee: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, fee: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, u64]>;1350 /**1351 * Transfer several currencies specifying the item to be used as fee1352 * 1353 * `dest_weight` is the weight for XCM execution on the dest chain, and1354 * it would be charged from the transferred assets. If set below1355 * requirements, the execution may fail and assets wouldn't be1356 * received.1357 * 1358 * `fee_item` is index of the currencies tuple that we want to use for1359 * payment1360 * 1361 * It's a no-op if any error on local XCM execution or message sending.1362 * Note sending assets out per se doesn't guarantee they would be1363 * received. Receiving depends on if the XCM message could be delivered1364 * by the network, and if the receiving chain would handle1365 * messages correctly.1366 **/1367 transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>> | ([PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, u64]>;1368 /**1369 * Transfer native currencies specifying the fee and amount as1370 * separate.1371 * 1372 * `dest_weight` is the weight for XCM execution on the dest chain, and1373 * it would be charged from the transferred assets. If set below1374 * requirements, the execution may fail and assets wouldn't be1375 * received.1376 * 1377 * `fee` is the amount to be spent to pay for execution in destination1378 * chain. Both fee and amount will be subtracted form the callers1379 * balance.1380 * 1381 * If `fee` is not high enough to cover for the execution costs in the1382 * destination chain, then the assets will be trapped in the1383 * destination chain1384 * 1385 * It's a no-op if any error on local XCM execution or message sending.1386 * Note sending assets out per se doesn't guarantee they would be1387 * received. Receiving depends on if the XCM message could be delivered1388 * by the network, and if the receiving chain would handle1389 * messages correctly.1390 **/1391 transferWithFee: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, u64]>;1392 /**1393 * Generic tx1394 **/1395 [key: string]: SubmittableExtrinsicFunction<ApiType>;1396 };1397 } // AugmentedSubmittables1398} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts76.2 KiBsourcehistory