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, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, 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 appPromotion: {21 /**22 * Recalculates interest for the specified number of stakers.23 * If all stakers are not recalculated, the next call of the extrinsic24 * will continue the recalculation, from those stakers for whom this25 * was not perform in last call.26 * 27 * # Permissions28 * 29 * * Pallet admin30 * 31 * # Arguments32 * 33 * * `stakers_number`: the number of stakers for which recalculation will be performed34 **/35 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;36 /**37 * Sets an address as the the admin.38 * 39 * # Permissions40 * 41 * * Sudo42 * 43 * # Arguments44 * 45 * * `admin`: account of the new admin.46 **/47 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;48 /**49 * Sets the pallet to be the sponsor for the collection.50 * 51 * # Permissions52 * 53 * * Pallet admin54 * 55 * # Arguments56 * 57 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`58 **/59 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;60 /**61 * Sets the pallet to be the sponsor for the contract.62 * 63 * # Permissions64 * 65 * * Pallet admin66 * 67 * # Arguments68 * 69 * * `contract_id`: the contract address that will be sponsored by `pallet_id`70 **/71 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;72 /**73 * Stakes the amount of native tokens.74 * Sets `amount` to the locked state.75 * The maximum number of stakes for a staker is 10.76 * 77 * # Arguments78 * 79 * * `amount`: in native tokens.80 **/81 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;82 /**83 * Removes the pallet as the sponsor for the collection.84 * Returns [`NoPermission`][`Error::NoPermission`]85 * if the pallet wasn't the sponsor.86 * 87 * # Permissions88 * 89 * * Pallet admin90 * 91 * # Arguments92 * 93 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`94 **/95 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;96 /**97 * Removes the pallet as the sponsor for the contract.98 * Returns [`NoPermission`][`Error::NoPermission`]99 * if the pallet wasn't the sponsor.100 * 101 * # Permissions102 * 103 * * Pallet admin104 * 105 * # Arguments106 * 107 * * `contract_id`: the contract address that is sponsored by `pallet_id`108 **/109 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;110 /**111 * Unstakes all stakes.112 * Moves the sum of all stakes to the `reserved` state.113 * After the end of `PendingInterval` this sum becomes completely114 * free for further use.115 **/116 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;117 /**118 * Generic tx119 **/120 [key: string]: SubmittableExtrinsicFunction<ApiType>;121 };122 balances: {123 /**124 * Exactly as `transfer`, except the origin must be root and the source account may be125 * specified.126 * # <weight>127 * - Same as transfer, but additional read and write because the source account is not128 * assumed to be in the overlay.129 * # </weight>130 **/131 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>]>;132 /**133 * Unreserve some balance from a user by force.134 * 135 * Can only be called by ROOT.136 **/137 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;138 /**139 * Set the balances of a given account.140 * 141 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will142 * also alter the total issuance of the system (`TotalIssuance`) appropriately.143 * If the new free or reserved balance is below the existential deposit,144 * it will reset the account nonce (`frame_system::AccountNonce`).145 * 146 * The dispatch origin for this call is `root`.147 **/148 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>]>;149 /**150 * Transfer some liquid free balance to another account.151 * 152 * `transfer` will set the `FreeBalance` of the sender and receiver.153 * If the sender's account is below the existential deposit as a result154 * of the transfer, the account will be reaped.155 * 156 * The dispatch origin for this call must be `Signed` by the transactor.157 * 158 * # <weight>159 * - Dependent on arguments but not critical, given proper implementations for input config160 * types. See related functions below.161 * - It contains a limited number of reads and writes internally and no complex162 * computation.163 * 164 * Related functions:165 * 166 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.167 * - Transferring balances to accounts that did not exist before will cause168 * `T::OnNewAccount::on_new_account` to be called.169 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.170 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check171 * that the transfer will not kill the origin account.172 * ---------------------------------173 * - Origin account is already in memory, so no DB operations for them.174 * # </weight>175 **/176 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>]>;177 /**178 * Transfer the entire transferable balance from the caller account.179 * 180 * NOTE: This function only attempts to transfer _transferable_ balances. This means that181 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be182 * transferred by this function. To ensure that this function results in a killed account,183 * you might need to prepare the account by removing any reference counters, storage184 * deposits, etc...185 * 186 * The dispatch origin of this call must be Signed.187 * 188 * - `dest`: The recipient of the transfer.189 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all190 * of the funds the account has, causing the sender account to be killed (false), or191 * transfer everything except at least the existential deposit, which will guarantee to192 * keep the sender account alive (true). # <weight>193 * - O(1). Just like transfer, but reading the user's transferable balance first.194 * #</weight>195 **/196 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;197 /**198 * Same as the [`transfer`] call, but with a check that the transfer will not kill the199 * origin account.200 * 201 * 99% of the time you want [`transfer`] instead.202 * 203 * [`transfer`]: struct.Pallet.html#method.transfer204 **/205 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>]>;206 /**207 * Generic tx208 **/209 [key: string]: SubmittableExtrinsicFunction<ApiType>;210 };211 charging: {212 /**213 * Generic tx214 **/215 [key: string]: SubmittableExtrinsicFunction<ApiType>;216 };217 configuration: {218 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;219 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;220 /**221 * Generic tx222 **/223 [key: string]: SubmittableExtrinsicFunction<ApiType>;224 };225 cumulusXcm: {226 /**227 * Generic tx228 **/229 [key: string]: SubmittableExtrinsicFunction<ApiType>;230 };231 dmpQueue: {232 /**233 * Service a single overweight message.234 * 235 * - `origin`: Must pass `ExecuteOverweightOrigin`.236 * - `index`: The index of the overweight message to service.237 * - `weight_limit`: The amount of weight that message execution may take.238 * 239 * Errors:240 * - `Unknown`: Message of `index` is unknown.241 * - `OverLimit`: Message execution may use greater than `weight_limit`.242 * 243 * Events:244 * - `OverweightServiced`: On success.245 **/246 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Weight]>;247 /**248 * Generic tx249 **/250 [key: string]: SubmittableExtrinsicFunction<ApiType>;251 };252 ethereum: {253 /**254 * Transact an Ethereum transaction.255 **/256 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;257 /**258 * Generic tx259 **/260 [key: string]: SubmittableExtrinsicFunction<ApiType>;261 };262 evm: {263 /**264 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.265 **/266 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>]>>]>;267 /**268 * Issue an EVM create operation. This is similar to a contract creation transaction in269 * Ethereum.270 **/271 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>]>>]>;272 /**273 * Issue an EVM create2 operation.274 **/275 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>]>>]>;276 /**277 * Withdraw balance from EVM into currency/balances pallet.278 **/279 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;280 /**281 * Generic tx282 **/283 [key: string]: SubmittableExtrinsicFunction<ApiType>;284 };285 evmMigration: {286 /**287 * Start contract migration, inserts contract stub at target address,288 * and marks account as pending, allowing to insert storage289 **/290 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;291 /**292 * Finish contract migration, allows it to be called.293 * It is not possible to alter contract storage via [`Self::set_data`]294 * after this call.295 **/296 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;297 /**298 * Insert items into contract storage, this method can be called299 * multiple times300 **/301 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;302 /**303 * Generic tx304 **/305 [key: string]: SubmittableExtrinsicFunction<ApiType>;306 };307 foreignAssets: {308 registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;309 updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;310 /**311 * Generic tx312 **/313 [key: string]: SubmittableExtrinsicFunction<ApiType>;314 };315 inflation: {316 /**317 * This method sets the inflation start date. Can be only called once.318 * Inflation start block can be backdated and will catch up. The method will create Treasury319 * account if it does not exist and perform the first inflation deposit.320 * 321 * # Permissions322 * 323 * * Root324 * 325 * # Arguments326 * 327 * * inflation_start_relay_block: The relay chain block at which inflation should start328 **/329 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;330 /**331 * Generic tx332 **/333 [key: string]: SubmittableExtrinsicFunction<ApiType>;334 };335 parachainSystem: {336 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;337 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;338 /**339 * Set the current validation data.340 * 341 * This should be invoked exactly once per block. It will panic at the finalization342 * phase if the call was not invoked.343 * 344 * The dispatch origin for this call must be `Inherent`345 * 346 * As a side effect, this function upgrades the current validation function347 * if the appropriate time has come.348 **/349 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;350 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;351 /**352 * Generic tx353 **/354 [key: string]: SubmittableExtrinsicFunction<ApiType>;355 };356 polkadotXcm: {357 /**358 * Execute an XCM message from a local, signed, origin.359 * 360 * An event is deposited indicating whether `msg` could be executed completely or only361 * partially.362 * 363 * No more than `max_weight` will be used in its attempted execution. If this is less than the364 * maximum amount of weight that the message could take to be executed, then no execution365 * attempt will be made.366 * 367 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully368 * to completion; only that *some* of it was executed.369 **/370 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, Weight]>;371 /**372 * Set a safe XCM version (the version that XCM should be encoded with if the most recent373 * version a destination can accept is unknown).374 * 375 * - `origin`: Must be Root.376 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.377 **/378 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;379 /**380 * Ask a location to notify us regarding their XCM version and any changes to it.381 * 382 * - `origin`: Must be Root.383 * - `location`: The location to which we should subscribe for XCM version notifications.384 **/385 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;386 /**387 * Require that a particular destination should no longer notify us regarding any XCM388 * version changes.389 * 390 * - `origin`: Must be Root.391 * - `location`: The location to which we are currently subscribed for XCM version392 * notifications which we no longer desire.393 **/394 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;395 /**396 * Extoll that a particular destination can be communicated with through a particular397 * version of XCM.398 * 399 * - `origin`: Must be Root.400 * - `location`: The destination that is being described.401 * - `xcm_version`: The latest version of XCM that `location` supports.402 **/403 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;404 /**405 * Transfer some assets from the local chain to the sovereign account of a destination406 * chain and forward a notification XCM.407 * 408 * Fee payment on the destination side is made from the asset in the `assets` vector of409 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight410 * is needed than `weight_limit`, then the operation will fail and the assets send may be411 * at risk.412 * 413 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.414 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send415 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.416 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be417 * an `AccountId32` value.418 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the419 * `dest` side.420 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay421 * fees.422 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.423 **/424 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]>;425 /**426 * Teleport some assets from the local chain to some destination chain.427 * 428 * Fee payment on the destination side is made from the asset in the `assets` vector of429 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight430 * is needed than `weight_limit`, then the operation will fail and the assets send may be431 * at risk.432 * 433 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.434 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send435 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.436 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be437 * an `AccountId32` value.438 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the439 * `dest` side. May not be empty.440 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay441 * fees.442 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.443 **/444 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]>;445 /**446 * Transfer some assets from the local chain to the sovereign account of a destination447 * chain and forward a notification XCM.448 * 449 * Fee payment on the destination side is made from the asset in the `assets` vector of450 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,451 * with all fees taken as needed from the asset.452 * 453 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.454 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send455 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.456 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be457 * an `AccountId32` value.458 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the459 * `dest` side.460 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay461 * fees.462 **/463 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]>;464 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;465 /**466 * Teleport some assets from the local chain to some destination chain.467 * 468 * Fee payment on the destination side is made from the asset in the `assets` vector of469 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,470 * with all fees taken as needed from the asset.471 * 472 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.473 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send474 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.475 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be476 * an `AccountId32` value.477 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the478 * `dest` side. May not be empty.479 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay480 * fees.481 **/482 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]>;483 /**484 * Generic tx485 **/486 [key: string]: SubmittableExtrinsicFunction<ApiType>;487 };488 rmrkCore: {489 /**490 * Accept an NFT sent from another account to self or an owned NFT.491 * 492 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.493 * 494 * # Permissions:495 * - Token-owner-to-be496 * 497 * # Arguments:498 * - `origin`: sender of the transaction499 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.500 * - `rmrk_nft_id`: ID of the NFT to be accepted.501 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,502 * whichever the accepted NFT was sent to.503 **/504 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;505 /**506 * Accept the addition of a newly created pending resource to an existing NFT.507 * 508 * This transaction is needed when a resource is created and assigned to an NFT509 * by a non-owner, i.e. the collection issuer, with one of the510 * [`add_...` transactions](Pallet::add_basic_resource).511 * 512 * # Permissions:513 * - Token owner514 * 515 * # Arguments:516 * - `origin`: sender of the transaction517 * - `rmrk_collection_id`: RMRK collection ID of the NFT.518 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.519 * - `resource_id`: ID of the newly created pending resource.520 * accept the addition of a new resource to an existing NFT521 **/522 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;523 /**524 * Accept the removal of a removal-pending resource from an NFT.525 * 526 * This transaction is needed when a non-owner, i.e. the collection issuer,527 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.528 * 529 * # Permissions:530 * - Token owner531 * 532 * # Arguments:533 * - `origin`: sender of the transaction534 * - `rmrk_collection_id`: RMRK collection ID of the NFT.535 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.536 * - `resource_id`: ID of the removal-pending resource.537 **/538 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;539 /**540 * Create and set/propose a basic resource for an NFT.541 * 542 * A basic resource is the simplest, lacking a Base and anything that comes with it.543 * See RMRK docs for more information and examples.544 * 545 * # Permissions:546 * - Collection issuer - if not the token owner, adding the resource will warrant547 * the owner's [acceptance](Pallet::accept_resource).548 * 549 * # Arguments:550 * - `origin`: sender of the transaction551 * - `rmrk_collection_id`: RMRK collection ID of the NFT.552 * - `nft_id`: ID of the NFT to assign a resource to.553 * - `resource`: Data of the resource to be created.554 **/555 addBasicResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceBasicResource | { src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceBasicResource]>;556 /**557 * Create and set/propose a composable resource for an NFT.558 * 559 * A composable resource links to a Base and has a subset of its Parts it is composed of.560 * See RMRK docs for more information and examples.561 * 562 * # Permissions:563 * - Collection issuer - if not the token owner, adding the resource will warrant564 * the owner's [acceptance](Pallet::accept_resource).565 * 566 * # Arguments:567 * - `origin`: sender of the transaction568 * - `rmrk_collection_id`: RMRK collection ID of the NFT.569 * - `nft_id`: ID of the NFT to assign a resource to.570 * - `resource`: Data of the resource to be created.571 **/572 addComposableResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceComposableResource | { parts?: any; base?: any; src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceComposableResource]>;573 /**574 * Create and set/propose a slot resource for an NFT.575 * 576 * A slot resource links to a Base and a slot ID in it which it can fit into.577 * See RMRK docs for more information and examples.578 * 579 * # Permissions:580 * - Collection issuer - if not the token owner, adding the resource will warrant581 * the owner's [acceptance](Pallet::accept_resource).582 * 583 * # Arguments:584 * - `origin`: sender of the transaction585 * - `rmrk_collection_id`: RMRK collection ID of the NFT.586 * - `nft_id`: ID of the NFT to assign a resource to.587 * - `resource`: Data of the resource to be created.588 **/589 addSlotResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceSlotResource | { base?: any; src?: any; metadata?: any; slot?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceSlotResource]>;590 /**591 * Burn an NFT, destroying it and its nested tokens up to the specified limit.592 * If the burning budget is exceeded, the transaction is reverted.593 * 594 * This is the way to burn a nested token as well.595 * 596 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).597 * 598 * # Permissions:599 * * Token owner600 * 601 * # Arguments:602 * - `origin`: sender of the transaction603 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.604 * - `nft_id`: ID of the NFT to be destroyed.605 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction606 * is reverted if there are more tokens to burn in the nesting tree than this number.607 * This is primarily a mechanism of transaction weight control.608 **/609 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;610 /**611 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).612 * 613 * # Permissions:614 * * Collection issuer615 * 616 * # Arguments:617 * - `origin`: sender of the transaction618 * - `collection_id`: RMRK collection ID to change the issuer of.619 * - `new_issuer`: Collection's new issuer.620 **/621 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;622 /**623 * Create a new collection of NFTs.624 * 625 * # Permissions:626 * * Anyone - will be assigned as the issuer of the collection.627 * 628 * # Arguments:629 * - `origin`: sender of the transaction630 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.631 * - `max`: Optional maximum number of tokens.632 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.633 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.634 **/635 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;636 /**637 * Destroy a collection.638 * 639 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.640 * 641 * # Permissions:642 * * Collection issuer643 * 644 * # Arguments:645 * - `origin`: sender of the transaction646 * - `collection_id`: RMRK ID of the collection to destroy.647 **/648 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;649 /**650 * "Lock" the collection and prevent new token creation. Cannot be undone.651 * 652 * # Permissions:653 * * Collection issuer654 * 655 * # Arguments:656 * - `origin`: sender of the transaction657 * - `collection_id`: RMRK ID of the collection to lock.658 **/659 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;660 /**661 * Mint an NFT in a specified collection.662 * 663 * # Permissions:664 * * Collection issuer665 * 666 * # Arguments:667 * - `origin`: sender of the transaction668 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).669 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.670 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.671 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.672 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.673 * - `transferable`: Can this NFT be transferred? Cannot be changed.674 * - `resources`: Resource data to be added to the NFT immediately after minting.675 **/676 mintNft: AugmentedSubmittable<(owner: Option<AccountId32> | null | Uint8Array | AccountId32 | string, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option<AccountId32> | null | Uint8Array | AccountId32 | string, royaltyAmount: Option<Permill> | null | Uint8Array | Permill | AnyNumber, metadata: Bytes | string | Uint8Array, transferable: bool | boolean | Uint8Array, resources: Option<Vec<RmrkTraitsResourceResourceTypes>> | null | Uint8Array | Vec<RmrkTraitsResourceResourceTypes> | (RmrkTraitsResourceResourceTypes | { Basic: any } | { Composable: any } | { Slot: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<AccountId32>, u32, Option<AccountId32>, Option<Permill>, Bytes, bool, Option<Vec<RmrkTraitsResourceResourceTypes>>]>;677 /**678 * Reject an NFT sent from another account to self or owned NFT.679 * The NFT in question will not be sent back and burnt instead.680 * 681 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.682 * 683 * # Permissions:684 * - Token-owner-to-be-not685 * 686 * # Arguments:687 * - `origin`: sender of the transaction688 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.689 * - `rmrk_nft_id`: ID of the NFT to be rejected.690 **/691 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;692 /**693 * Remove and erase a resource from an NFT.694 * 695 * If the sender does not own the NFT, then it will be pending confirmation,696 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.697 * 698 * # Permissions699 * - Collection issuer700 * 701 * # Arguments702 * - `origin`: sender of the transaction703 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.704 * - `nft_id`: ID of the NFT with a resource to be removed.705 * - `resource_id`: ID of the resource to be removed.706 **/707 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;708 /**709 * Transfer an NFT from an account/NFT A to another account/NFT B.710 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].711 * 712 * If the target owner is an NFT owned by another account, then the NFT will enter713 * the pending state and will have to be accepted by the other account.714 * 715 * # Permissions:716 * - Token owner717 * 718 * # Arguments:719 * - `origin`: sender of the transaction720 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.721 * - `rmrk_nft_id`: ID of the NFT to be transferred.722 * - `new_owner`: New owner of the nft which can be either an account or a NFT.723 **/724 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;725 /**726 * Set a different order of resource priorities for an NFT. Priorities can be used,727 * for example, for order of rendering.728 * 729 * Note that the priorities are not updated automatically, and are an empty vector730 * by default. There is no pre-set definition for the order to be particular,731 * it can be interpreted arbitrarily use-case by use-case.732 * 733 * # Permissions:734 * - Token owner735 * 736 * # Arguments:737 * - `origin`: sender of the transaction738 * - `rmrk_collection_id`: RMRK collection ID of the NFT.739 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.740 * - `priorities`: Ordered vector of resource IDs.741 **/742 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;743 /**744 * Add or edit a custom user property, a key-value pair, describing the metadata745 * of a token or a collection, on either one of these.746 * 747 * Note that in this proxy implementation many details regarding RMRK are stored748 * as scoped properties prefixed with "rmrk:", normally inaccessible749 * to external transactions and RPCs.750 * 751 * # Permissions:752 * - Collection issuer - in case of collection property753 * - Token owner - in case of NFT property754 * 755 * # Arguments:756 * - `origin`: sender of the transaction757 * - `rmrk_collection_id`: RMRK collection ID.758 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.759 * - `key`: Key of the custom property to be referenced by.760 * - `value`: Value of the custom property to be stored.761 **/762 setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact<u32> | AnyNumber | Uint8Array, maybeNftId: Option<u32> | null | Uint8Array | u32 | AnyNumber, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Option<u32>, Bytes, Bytes]>;763 /**764 * Generic tx765 **/766 [key: string]: SubmittableExtrinsicFunction<ApiType>;767 };768 rmrkEquip: {769 /**770 * Create a new Base.771 * 772 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)773 * 774 * # Permissions775 * - Anyone - will be assigned as the issuer of the Base.776 * 777 * # Arguments:778 * - `origin`: Caller, will be assigned as the issuer of the Base779 * - `base_type`: Arbitrary media type, e.g. "svg".780 * - `symbol`: Arbitrary client-chosen symbol.781 * - `parts`: Array of Fixed and Slot Parts composing the Base,782 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).783 **/784 createBase: AugmentedSubmittable<(baseType: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, parts: Vec<RmrkTraitsPartPartType> | (RmrkTraitsPartPartType | { FixedPart: any } | { SlotPart: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes, Vec<RmrkTraitsPartPartType>]>;785 /**786 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.787 * 788 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).789 * 790 * # Permissions:791 * - Base issuer792 * 793 * # Arguments:794 * - `origin`: sender of the transaction795 * - `base_id`: Base containing the Slot Part to be updated.796 * - `slot_id`: Slot Part whose Equippable List is being updated .797 * - `equippables`: List of equippables that will override the current Equippables list.798 **/799 equippable: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, slotId: u32 | AnyNumber | Uint8Array, equippables: RmrkTraitsPartEquippableList | { All: any } | { Empty: any } | { Custom: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsPartEquippableList]>;800 /**801 * Add a Theme to a Base.802 * A Theme named "default" is required prior to adding other Themes.803 * 804 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).805 * 806 * # Permissions:807 * - Base issuer808 * 809 * # Arguments:810 * - `origin`: sender of the transaction811 * - `base_id`: Base ID containing the Theme to be updated.812 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an813 * array of [key, value, inherit].814 * - `key`: Arbitrary BoundedString, defined by client.815 * - `value`: Arbitrary BoundedString, defined by client.816 * - `inherit`: Optional bool.817 **/818 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;819 /**820 * Generic tx821 **/822 [key: string]: SubmittableExtrinsicFunction<ApiType>;823 };824 structure: {825 /**826 * Generic tx827 **/828 [key: string]: SubmittableExtrinsicFunction<ApiType>;829 };830 sudo: {831 /**832 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo833 * key.834 * 835 * The dispatch origin for this call must be _Signed_.836 * 837 * # <weight>838 * - O(1).839 * - Limited storage reads.840 * - One DB change.841 * # </weight>842 **/843 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;844 /**845 * Authenticates the sudo key and dispatches a function call with `Root` origin.846 * 847 * The dispatch origin for this call must be _Signed_.848 * 849 * # <weight>850 * - O(1).851 * - Limited storage reads.852 * - One DB write (event).853 * - Weight of derivative `call` execution + 10,000.854 * # </weight>855 **/856 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;857 /**858 * Authenticates the sudo key and dispatches a function call with `Signed` origin from859 * a given account.860 * 861 * The dispatch origin for this call must be _Signed_.862 * 863 * # <weight>864 * - O(1).865 * - Limited storage reads.866 * - One DB write (event).867 * - Weight of derivative `call` execution + 10,000.868 * # </weight>869 **/870 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]>;871 /**872 * Authenticates the sudo key and dispatches a function call with `Root` origin.873 * This function does not check the weight of the call, and instead allows the874 * Sudo user to specify the weight of the call.875 * 876 * The dispatch origin for this call must be _Signed_.877 * 878 * # <weight>879 * - O(1).880 * - The weight of this call is defined by the caller.881 * # </weight>882 **/883 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Weight]>;884 /**885 * Generic tx886 **/887 [key: string]: SubmittableExtrinsicFunction<ApiType>;888 };889 system: {890 /**891 * A dispatch that will fill the block weight up to the given ratio.892 **/893 fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;894 /**895 * Kill all storage items with a key that starts with the given prefix.896 * 897 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under898 * the prefix we are removing to accurately calculate the weight of this function.899 **/900 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;901 /**902 * Kill some items from storage.903 **/904 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;905 /**906 * Make some on-chain remark.907 * 908 * # <weight>909 * - `O(1)`910 * # </weight>911 **/912 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;913 /**914 * Make some on-chain remark and emit event.915 **/916 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;917 /**918 * Set the new runtime code.919 * 920 * # <weight>921 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`922 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is923 * expensive).924 * - 1 storage write (codec `O(C)`).925 * - 1 digest item.926 * - 1 event.927 * The weight of this function is dependent on the runtime, but generally this is very928 * expensive. We will treat this as a full block.929 * # </weight>930 **/931 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;932 /**933 * Set the new runtime code without doing any checks of the given `code`.934 * 935 * # <weight>936 * - `O(C)` where `C` length of `code`937 * - 1 storage write (codec `O(C)`).938 * - 1 digest item.939 * - 1 event.940 * The weight of this function is dependent on the runtime. We will treat this as a full941 * block. # </weight>942 **/943 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;944 /**945 * Set the number of pages in the WebAssembly environment's heap.946 **/947 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;948 /**949 * Set some items of storage.950 **/951 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;952 /**953 * Generic tx954 **/955 [key: string]: SubmittableExtrinsicFunction<ApiType>;956 };957 timestamp: {958 /**959 * Set the current time.960 * 961 * This call should be invoked exactly once per block. It will panic at the finalization962 * phase, if this call hasn't been invoked by that time.963 * 964 * The timestamp should be greater than the previous one by the amount specified by965 * `MinimumPeriod`.966 * 967 * The dispatch origin for this call must be `Inherent`.968 * 969 * # <weight>970 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)971 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in972 * `on_finalize`)973 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.974 * # </weight>975 **/976 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;977 /**978 * Generic tx979 **/980 [key: string]: SubmittableExtrinsicFunction<ApiType>;981 };982 tokens: {983 /**984 * Exactly as `transfer`, except the origin must be root and the source985 * account may be specified.986 * 987 * The dispatch origin for this call must be _Root_.988 * 989 * - `source`: The sender of the transfer.990 * - `dest`: The recipient of the transfer.991 * - `currency_id`: currency type.992 * - `amount`: free balance amount to tranfer.993 **/994 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>]>;995 /**996 * Set the balances of a given account.997 * 998 * This will alter `FreeBalance` and `ReservedBalance` in storage. it999 * will also decrease the total issuance of the system1000 * (`TotalIssuance`). If the new free or reserved balance is below the1001 * existential deposit, it will reap the `AccountInfo`.1002 * 1003 * The dispatch origin for this call is `root`.1004 **/1005 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>]>;1006 /**1007 * Transfer some liquid free balance to another account.1008 * 1009 * `transfer` will set the `FreeBalance` of the sender and receiver.1010 * It will decrease the total issuance of the system by the1011 * `TransferFee`. If the sender's account is below the existential1012 * deposit as a result of the transfer, the account will be reaped.1013 * 1014 * The dispatch origin for this call must be `Signed` by the1015 * transactor.1016 * 1017 * - `dest`: The recipient of the transfer.1018 * - `currency_id`: currency type.1019 * - `amount`: free balance amount to tranfer.1020 **/1021 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>]>;1022 /**1023 * Transfer all remaining balance to the given account.1024 * 1025 * NOTE: This function only attempts to transfer _transferable_1026 * balances. This means that any locked, reserved, or existential1027 * deposits (when `keep_alive` is `true`), will not be transferred by1028 * this function. To ensure that this function results in a killed1029 * account, you might need to prepare the account by removing any1030 * reference counters, storage deposits, etc...1031 * 1032 * The dispatch origin for this call must be `Signed` by the1033 * transactor.1034 * 1035 * - `dest`: The recipient of the transfer.1036 * - `currency_id`: currency type.1037 * - `keep_alive`: A boolean to determine if the `transfer_all`1038 * operation should send all of the funds the account has, causing1039 * the sender account to be killed (false), or transfer everything1040 * except at least the existential deposit, which will guarantee to1041 * keep the sender account alive (true).1042 **/1043 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]>;1044 /**1045 * Same as the [`transfer`] call, but with a check that the transfer1046 * will not kill the origin account.1047 * 1048 * 99% of the time you want [`transfer`] instead.1049 * 1050 * The dispatch origin for this call must be `Signed` by the1051 * transactor.1052 * 1053 * - `dest`: The recipient of the transfer.1054 * - `currency_id`: currency type.1055 * - `amount`: free balance amount to tranfer.1056 **/1057 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>]>;1058 /**1059 * Generic tx1060 **/1061 [key: string]: SubmittableExtrinsicFunction<ApiType>;1062 };1063 treasury: {1064 /**1065 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1066 * and the original deposit will be returned.1067 * 1068 * May only be called from `T::ApproveOrigin`.1069 * 1070 * # <weight>1071 * - Complexity: O(1).1072 * - DbReads: `Proposals`, `Approvals`1073 * - DbWrite: `Approvals`1074 * # </weight>1075 **/1076 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1077 /**1078 * Put forward a suggestion for spending. A deposit proportional to the value1079 * is reserved and slashed if the proposal is rejected. It is returned once the1080 * proposal is awarded.1081 * 1082 * # <weight>1083 * - Complexity: O(1)1084 * - DbReads: `ProposalCount`, `origin account`1085 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1086 * # </weight>1087 **/1088 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]>;1089 /**1090 * Reject a proposed spend. The original deposit will be slashed.1091 * 1092 * May only be called from `T::RejectOrigin`.1093 * 1094 * # <weight>1095 * - Complexity: O(1)1096 * - DbReads: `Proposals`, `rejected proposer account`1097 * - DbWrites: `Proposals`, `rejected proposer account`1098 * # </weight>1099 **/1100 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1101 /**1102 * Force a previously approved proposal to be removed from the approval queue.1103 * The original deposit will no longer be returned.1104 * 1105 * May only be called from `T::RejectOrigin`.1106 * - `proposal_id`: The index of a proposal1107 * 1108 * # <weight>1109 * - Complexity: O(A) where `A` is the number of approvals1110 * - Db reads and writes: `Approvals`1111 * # </weight>1112 * 1113 * Errors:1114 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1115 * i.e., the proposal has not been approved. This could also mean the proposal does not1116 * exist altogether, thus there is no way it would have been approved in the first place.1117 **/1118 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1119 /**1120 * Propose and approve a spend of treasury funds.1121 * 1122 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1123 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1124 * - `beneficiary`: The destination account for the transfer.1125 * 1126 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1127 * beneficiary.1128 **/1129 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]>;1130 /**1131 * Generic tx1132 **/1133 [key: string]: SubmittableExtrinsicFunction<ApiType>;1134 };1135 unique: {1136 /**1137 * Add an admin to a collection.1138 * 1139 * NFT Collection can be controlled by multiple admin addresses1140 * (some which can also be servers, for example). Admins can issue1141 * and burn NFTs, as well as add and remove other admins,1142 * but cannot change NFT or Collection ownership.1143 * 1144 * # Permissions1145 * 1146 * * Collection owner1147 * * Collection admin1148 * 1149 * # Arguments1150 * 1151 * * `collection_id`: ID of the Collection to add an admin for.1152 * * `new_admin`: Address of new admin to add.1153 **/1154 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1155 /**1156 * Add an address to allow list.1157 * 1158 * # Permissions1159 * 1160 * * Collection owner1161 * * Collection admin1162 * 1163 * # Arguments1164 * 1165 * * `collection_id`: ID of the modified collection.1166 * * `address`: ID of the address to be added to the allowlist.1167 **/1168 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1169 /**1170 * Allow a non-permissioned address to transfer or burn an item.1171 * 1172 * # Permissions1173 * 1174 * * Collection owner1175 * * Collection admin1176 * * Current item owner1177 * 1178 * # Arguments1179 * 1180 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1181 * * `collection_id`: ID of the collection the item belongs to.1182 * * `item_id`: ID of the item transactions on which are now approved.1183 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1184 * Set to 0 to revoke the approval.1185 **/1186 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]>;1187 /**1188 * Destroy a token on behalf of the owner as a non-owner account.1189 * 1190 * See also: [`approve`][`Pallet::approve`].1191 * 1192 * After this method executes, one approval is removed from the total so that1193 * the approved address will not be able to transfer this item again from this owner.1194 * 1195 * # Permissions1196 * 1197 * * Collection owner1198 * * Collection admin1199 * * Current token owner1200 * * Address approved by current item owner1201 * 1202 * # Arguments1203 * 1204 * * `from`: The owner of the burning item.1205 * * `collection_id`: ID of the collection to which the item belongs.1206 * * `item_id`: ID of item to burn.1207 * * `value`: Number of pieces to burn.1208 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1209 * * Fungible Mode: The desired number of pieces to burn.1210 * * Re-Fungible Mode: The desired number of pieces to burn.1211 **/1212 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]>;1213 /**1214 * Destroy an item.1215 * 1216 * # Permissions1217 * 1218 * * Collection owner1219 * * Collection admin1220 * * Current item owner1221 * 1222 * # Arguments1223 * 1224 * * `collection_id`: ID of the collection to which the item belongs.1225 * * `item_id`: ID of item to burn.1226 * * `value`: Number of pieces of the item to destroy.1227 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1228 * * Fungible Mode: The desired number of pieces to burn.1229 * * Re-Fungible Mode: The desired number of pieces to burn.1230 **/1231 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1232 /**1233 * Change the owner of the collection.1234 * 1235 * # Permissions1236 * 1237 * * Collection owner1238 * 1239 * # Arguments1240 * 1241 * * `collection_id`: ID of the modified collection.1242 * * `new_owner`: ID of the account that will become the owner.1243 **/1244 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1245 /**1246 * Confirm own sponsorship of a collection, becoming the sponsor.1247 * 1248 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1249 * Sponsor can pay the fees of a transaction instead of the sender,1250 * but only within specified limits.1251 * 1252 * # Permissions1253 * 1254 * * Sponsor-to-be1255 * 1256 * # Arguments1257 * 1258 * * `collection_id`: ID of the collection with the pending sponsor.1259 **/1260 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1261 /**1262 * Create a collection of tokens.1263 * 1264 * Each Token may have multiple properties encoded as an array of bytes1265 * of certain length. The initial owner of the collection is set1266 * to the address that signed the transaction and can be changed later.1267 * 1268 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1269 * 1270 * # Permissions1271 * 1272 * * Anyone - becomes the owner of the new collection.1273 * 1274 * # Arguments1275 * 1276 * * `collection_name`: Wide-character string with collection name1277 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1278 * * `collection_description`: Wide-character string with collection description1279 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1280 * * `token_prefix`: Byte string containing the token prefix to mark a collection1281 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1282 * * `mode`: Type of items stored in the collection and type dependent data.1283 **/1284 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]>;1285 /**1286 * Create a collection with explicit parameters.1287 * 1288 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1289 * 1290 * # Permissions1291 * 1292 * * Anyone - becomes the owner of the new collection.1293 * 1294 * # Arguments1295 * 1296 * * `data`: Explicit data of a collection used for its creation.1297 **/1298 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]>;1299 /**1300 * Mint an item within a collection.1301 * 1302 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1303 * 1304 * # Permissions1305 * 1306 * * Collection owner1307 * * Collection admin1308 * * Anyone if1309 * * Allow List is enabled, and1310 * * Address is added to allow list, and1311 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1312 * 1313 * # Arguments1314 * 1315 * * `collection_id`: ID of the collection to which an item would belong.1316 * * `owner`: Address of the initial owner of the item.1317 * * `data`: Token data describing the item to store on chain.1318 **/1319 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]>;1320 /**1321 * Create multiple items within a collection.1322 * 1323 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1324 * 1325 * # Permissions1326 * 1327 * * Collection owner1328 * * Collection admin1329 * * Anyone if1330 * * Allow List is enabled, and1331 * * Address is added to the allow list, and1332 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1333 * 1334 * # Arguments1335 * 1336 * * `collection_id`: ID of the collection to which the tokens would belong.1337 * * `owner`: Address of the initial owner of the tokens.1338 * * `items_data`: Vector of data describing each item to be created.1339 **/1340 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>]>;1341 /**1342 * Create multiple items within a collection with explicitly specified initial parameters.1343 * 1344 * # Permissions1345 * 1346 * * Collection owner1347 * * Collection admin1348 * * Anyone if1349 * * Allow List is enabled, and1350 * * Address is added to allow list, and1351 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1352 * 1353 * # Arguments1354 * 1355 * * `collection_id`: ID of the collection to which the tokens would belong.1356 * * `data`: Explicit item creation data.1357 **/1358 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1359 /**1360 * Delete specified collection properties.1361 * 1362 * # Permissions1363 * 1364 * * Collection Owner1365 * * Collection Admin1366 * 1367 * # Arguments1368 * 1369 * * `collection_id`: ID of the modified collection.1370 * * `property_keys`: Vector of keys of the properties to be deleted.1371 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1372 **/1373 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1374 /**1375 * Delete specified token properties. Currently properties only work with NFTs.1376 * 1377 * # Permissions1378 * 1379 * * Depends on collection's token property permissions and specified property mutability:1380 * * Collection owner1381 * * Collection admin1382 * * Token owner1383 * 1384 * # Arguments1385 * 1386 * * `collection_id`: ID of the collection to which the token belongs.1387 * * `token_id`: ID of the modified token.1388 * * `property_keys`: Vector of keys of the properties to be deleted.1389 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1390 **/1391 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1392 /**1393 * Destroy a collection if no tokens exist within.1394 * 1395 * # Permissions1396 * 1397 * * Collection owner1398 * 1399 * # Arguments1400 * 1401 * * `collection_id`: Collection to destroy.1402 **/1403 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1404 /**1405 * Remove admin of a collection.1406 * 1407 * An admin address can remove itself. List of admins may become empty,1408 * in which case only Collection Owner will be able to add an Admin.1409 * 1410 * # Permissions1411 * 1412 * * Collection owner1413 * * Collection admin1414 * 1415 * # Arguments1416 * 1417 * * `collection_id`: ID of the collection to remove the admin for.1418 * * `account_id`: Address of the admin to remove.1419 **/1420 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1421 /**1422 * Remove a collection's a sponsor, making everyone pay for their own transactions.1423 * 1424 * # Permissions1425 * 1426 * * Collection owner1427 * 1428 * # Arguments1429 * 1430 * * `collection_id`: ID of the collection with the sponsor to remove.1431 **/1432 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1433 /**1434 * Remove an address from allow list.1435 * 1436 * # Permissions1437 * 1438 * * Collection owner1439 * * Collection admin1440 * 1441 * # Arguments1442 * 1443 * * `collection_id`: ID of the modified collection.1444 * * `address`: ID of the address to be removed from the allowlist.1445 **/1446 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1447 /**1448 * Re-partition a refungible token, while owning all of its parts/pieces.1449 * 1450 * # Permissions1451 * 1452 * * Token owner (must own every part)1453 * 1454 * # Arguments1455 * 1456 * * `collection_id`: ID of the collection the RFT belongs to.1457 * * `token_id`: ID of the RFT.1458 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1459 **/1460 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1461 /**1462 * Set specific limits of a collection. Empty, or None fields mean chain default.1463 * 1464 * # Permissions1465 * 1466 * * Collection owner1467 * * Collection admin1468 * 1469 * # Arguments1470 * 1471 * * `collection_id`: ID of the modified collection.1472 * * `new_limit`: New limits of the collection. Fields that are not set (None)1473 * will not overwrite the old ones.1474 **/1475 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]>;1476 /**1477 * Set specific permissions of a collection. Empty, or None fields mean chain default.1478 * 1479 * # Permissions1480 * 1481 * * Collection owner1482 * * Collection admin1483 * 1484 * # Arguments1485 * 1486 * * `collection_id`: ID of the modified collection.1487 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1488 * will not overwrite the old ones.1489 **/1490 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1491 /**1492 * Add or change collection properties.1493 * 1494 * # Permissions1495 * 1496 * * Collection owner1497 * * Collection admin1498 * 1499 * # Arguments1500 * 1501 * * `collection_id`: ID of the modified collection.1502 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1503 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1504 **/1505 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1506 /**1507 * Set (invite) a new collection sponsor.1508 * 1509 * If successful, confirmation from the sponsor-to-be will be pending.1510 * 1511 * # Permissions1512 * 1513 * * Collection owner1514 * * Collection admin1515 * 1516 * # Arguments1517 * 1518 * * `collection_id`: ID of the modified collection.1519 * * `new_sponsor`: ID of the account of the sponsor-to-be.1520 **/1521 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1522 /**1523 * Add or change token properties according to collection's permissions.1524 * Currently properties only work with NFTs.1525 * 1526 * # Permissions1527 * 1528 * * Depends on collection's token property permissions and specified property mutability:1529 * * Collection owner1530 * * Collection admin1531 * * Token owner1532 * 1533 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1534 * 1535 * # Arguments1536 * 1537 * * `collection_id: ID of the collection to which the token belongs.1538 * * `token_id`: ID of the modified token.1539 * * `properties`: Vector of key-value pairs stored as the token's metadata.1540 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1541 **/1542 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>]>;1543 /**1544 * Add or change token property permissions of a collection.1545 * 1546 * Without a permission for a particular key, a property with that key1547 * cannot be created in a token.1548 * 1549 * # Permissions1550 * 1551 * * Collection owner1552 * * Collection admin1553 * 1554 * # Arguments1555 * 1556 * * `collection_id`: ID of the modified collection.1557 * * `property_permissions`: Vector of permissions for property keys.1558 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1559 **/1560 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1561 /**1562 * Completely allow or disallow transfers for a particular collection.1563 * 1564 * # Permissions1565 * 1566 * * Collection owner1567 * 1568 * # Arguments1569 * 1570 * * `collection_id`: ID of the collection.1571 * * `value`: New value of the flag, are transfers allowed?1572 **/1573 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1574 /**1575 * Change ownership of the token.1576 * 1577 * # Permissions1578 * 1579 * * Collection owner1580 * * Collection admin1581 * * Current token owner1582 * 1583 * # Arguments1584 * 1585 * * `recipient`: Address of token recipient.1586 * * `collection_id`: ID of the collection the item belongs to.1587 * * `item_id`: ID of the item.1588 * * Non-Fungible Mode: Required.1589 * * Fungible Mode: Ignored.1590 * * Re-Fungible Mode: Required.1591 * 1592 * * `value`: Amount to transfer.1593 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1594 * * Fungible Mode: The desired number of pieces to transfer.1595 * * Re-Fungible Mode: The desired number of pieces to transfer.1596 **/1597 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]>;1598 /**1599 * Change ownership of an item on behalf of the owner as a non-owner account.1600 * 1601 * See the [`approve`][`Pallet::approve`] method for additional information.1602 * 1603 * After this method executes, one approval is removed from the total so that1604 * the approved address will not be able to transfer this item again from this owner.1605 * 1606 * # Permissions1607 * 1608 * * Collection owner1609 * * Collection admin1610 * * Current item owner1611 * * Address approved by current item owner1612 * 1613 * # Arguments1614 * 1615 * * `from`: Address that currently owns the token.1616 * * `recipient`: Address of the new token-owner-to-be.1617 * * `collection_id`: ID of the collection the item.1618 * * `item_id`: ID of the item to be transferred.1619 * * `value`: Amount to transfer.1620 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1621 * * Fungible Mode: The desired number of pieces to transfer.1622 * * Re-Fungible Mode: The desired number of pieces to transfer.1623 **/1624 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]>;1625 /**1626 * Generic tx1627 **/1628 [key: string]: SubmittableExtrinsicFunction<ApiType>;1629 };1630 vesting: {1631 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1632 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1633 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>]>;1634 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]>;1635 /**1636 * Generic tx1637 **/1638 [key: string]: SubmittableExtrinsicFunction<ApiType>;1639 };1640 xcmpQueue: {1641 /**1642 * Resumes all XCM executions for the XCMP queue.1643 * 1644 * Note that this function doesn't change the status of the in/out bound channels.1645 * 1646 * - `origin`: Must pass `ControllerOrigin`.1647 **/1648 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1649 /**1650 * Services a single overweight XCM.1651 * 1652 * - `origin`: Must pass `ExecuteOverweightOrigin`.1653 * - `index`: The index of the overweight XCM to service1654 * - `weight_limit`: The amount of weight that XCM execution may take.1655 * 1656 * Errors:1657 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1658 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1659 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1660 * 1661 * Events:1662 * - `OverweightServiced`: On success.1663 **/1664 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, Weight]>;1665 /**1666 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1667 * 1668 * - `origin`: Must pass `ControllerOrigin`.1669 **/1670 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1671 /**1672 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1673 * messages from the channel.1674 * 1675 * - `origin`: Must pass `Root`.1676 * - `new`: Desired value for `QueueConfigData.drop_threshold`1677 **/1678 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1679 /**1680 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1681 * message sending may recommence after it has been suspended.1682 * 1683 * - `origin`: Must pass `Root`.1684 * - `new`: Desired value for `QueueConfigData.resume_threshold`1685 **/1686 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1687 /**1688 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1689 * suspend their sending.1690 * 1691 * - `origin`: Must pass `Root`.1692 * - `new`: Desired value for `QueueConfigData.suspend_value`1693 **/1694 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1695 /**1696 * Overwrites the amount of remaining weight under which we stop processing messages.1697 * 1698 * - `origin`: Must pass `Root`.1699 * - `new`: Desired value for `QueueConfigData.threshold_weight`1700 **/1701 updateThresholdWeight: AugmentedSubmittable<(updated: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Weight]>;1702 /**1703 * Overwrites the speed to which the available weight approaches the maximum weight.1704 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1705 * 1706 * - `origin`: Must pass `Root`.1707 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1708 **/1709 updateWeightRestrictDecay: AugmentedSubmittable<(updated: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Weight]>;1710 /**1711 * Overwrite the maximum amount of weight any individual message may consume.1712 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1713 * 1714 * - `origin`: Must pass `Root`.1715 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1716 **/1717 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Weight]>;1718 /**1719 * Generic tx1720 **/1721 [key: string]: SubmittableExtrinsicFunction<ApiType>;1722 };1723 xTokens: {1724 /**1725 * Transfer native currencies.1726 * 1727 * `dest_weight` is the weight for XCM execution on the dest chain, and1728 * it would be charged from the transferred assets. If set below1729 * requirements, the execution may fail and assets wouldn't be1730 * received.1731 * 1732 * It's a no-op if any error on local XCM execution or message sending.1733 * Note sending assets out per se doesn't guarantee they would be1734 * received. Receiving depends on if the XCM message could be delivered1735 * by the network, and if the receiving chain would handle1736 * messages correctly.1737 **/1738 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]>;1739 /**1740 * Transfer `MultiAsset`.1741 * 1742 * `dest_weight` is the weight for XCM execution on the dest chain, and1743 * it would be charged from the transferred assets. If set below1744 * requirements, the execution may fail and assets wouldn't be1745 * received.1746 * 1747 * It's a no-op if any error on local XCM execution or message sending.1748 * Note sending assets out per se doesn't guarantee they would be1749 * received. Receiving depends on if the XCM message could be delivered1750 * by the network, and if the receiving chain would handle1751 * messages correctly.1752 **/1753 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]>;1754 /**1755 * Transfer several `MultiAsset` specifying the item to be used as fee1756 * 1757 * `dest_weight` is the weight for XCM execution on the dest chain, and1758 * it would be charged from the transferred assets. If set below1759 * requirements, the execution may fail and assets wouldn't be1760 * received.1761 * 1762 * `fee_item` is index of the MultiAssets that we want to use for1763 * payment1764 * 1765 * It's a no-op if any error on local XCM execution or message sending.1766 * Note sending assets out per se doesn't guarantee they would be1767 * received. Receiving depends on if the XCM message could be delivered1768 * by the network, and if the receiving chain would handle1769 * messages correctly.1770 **/1771 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]>;1772 /**1773 * Transfer `MultiAsset` specifying the fee and amount as separate.1774 * 1775 * `dest_weight` is the weight for XCM execution on the dest chain, and1776 * it would be charged from the transferred assets. If set below1777 * requirements, the execution may fail and assets wouldn't be1778 * received.1779 * 1780 * `fee` is the multiasset to be spent to pay for execution in1781 * destination chain. Both fee and amount will be subtracted form the1782 * callers balance For now we only accept fee and asset having the same1783 * `MultiLocation` id.1784 * 1785 * If `fee` is not high enough to cover for the execution costs in the1786 * destination chain, then the assets will be trapped in the1787 * destination chain1788 * 1789 * It's a no-op if any error on local XCM execution or message sending.1790 * Note sending assets out per se doesn't guarantee they would be1791 * received. Receiving depends on if the XCM message could be delivered1792 * by the network, and if the receiving chain would handle1793 * messages correctly.1794 **/1795 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]>;1796 /**1797 * Transfer several currencies specifying the item to be used as fee1798 * 1799 * `dest_weight` is the weight for XCM execution on the dest chain, and1800 * it would be charged from the transferred assets. If set below1801 * requirements, the execution may fail and assets wouldn't be1802 * received.1803 * 1804 * `fee_item` is index of the currencies tuple that we want to use for1805 * payment1806 * 1807 * It's a no-op if any error on local XCM execution or message sending.1808 * Note sending assets out per se doesn't guarantee they would be1809 * received. Receiving depends on if the XCM message could be delivered1810 * by the network, and if the receiving chain would handle1811 * messages correctly.1812 **/1813 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]>;1814 /**1815 * Transfer native currencies specifying the fee and amount as1816 * separate.1817 * 1818 * `dest_weight` is the weight for XCM execution on the dest chain, and1819 * it would be charged from the transferred assets. If set below1820 * requirements, the execution may fail and assets wouldn't be1821 * received.1822 * 1823 * `fee` is the amount to be spent to pay for execution in destination1824 * chain. Both fee and amount will be subtracted form the callers1825 * balance.1826 * 1827 * If `fee` is not high enough to cover for the execution costs in the1828 * destination chain, then the assets will be trapped in the1829 * destination chain1830 * 1831 * It's a no-op if any error on local XCM execution or message sending.1832 * Note sending assets out per se doesn't guarantee they would be1833 * received. Receiving depends on if the XCM message could be delivered1834 * by the network, and if the receiving chain would handle1835 * messages correctly.1836 **/1837 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]>;1838 /**1839 * Generic tx1840 **/1841 [key: string]: SubmittableExtrinsicFunction<ApiType>;1842 };1843 } // AugmentedSubmittables1844} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts99.9 KiBsourcehistory