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, U8aFixed, 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 } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, FrameSupportScheduleMaybeHashed, 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 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;22 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;23 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;24 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;25 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;26 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;27 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;28 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;29 /**30 * Generic tx31 **/32 [key: string]: SubmittableExtrinsicFunction<ApiType>;33 };34 balances: {35 /**36 * Exactly as `transfer`, except the origin must be root and the source account may be37 * specified.38 * # <weight>39 * - Same as transfer, but additional read and write because the source account is not40 * assumed to be in the overlay.41 * # </weight>42 **/43 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>]>;44 /**45 * Unreserve some balance from a user by force.46 * 47 * Can only be called by ROOT.48 **/49 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;50 /**51 * Set the balances of a given account.52 * 53 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will54 * also alter the total issuance of the system (`TotalIssuance`) appropriately.55 * If the new free or reserved balance is below the existential deposit,56 * it will reset the account nonce (`frame_system::AccountNonce`).57 * 58 * The dispatch origin for this call is `root`.59 **/60 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>]>;61 /**62 * Transfer some liquid free balance to another account.63 * 64 * `transfer` will set the `FreeBalance` of the sender and receiver.65 * If the sender's account is below the existential deposit as a result66 * of the transfer, the account will be reaped.67 * 68 * The dispatch origin for this call must be `Signed` by the transactor.69 * 70 * # <weight>71 * - Dependent on arguments but not critical, given proper implementations for input config72 * types. See related functions below.73 * - It contains a limited number of reads and writes internally and no complex74 * computation.75 * 76 * Related functions:77 * 78 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.79 * - Transferring balances to accounts that did not exist before will cause80 * `T::OnNewAccount::on_new_account` to be called.81 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.82 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check83 * that the transfer will not kill the origin account.84 * ---------------------------------85 * - Origin account is already in memory, so no DB operations for them.86 * # </weight>87 **/88 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>]>;89 /**90 * Transfer the entire transferable balance from the caller account.91 * 92 * NOTE: This function only attempts to transfer _transferable_ balances. This means that93 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be94 * transferred by this function. To ensure that this function results in a killed account,95 * you might need to prepare the account by removing any reference counters, storage96 * deposits, etc...97 * 98 * The dispatch origin of this call must be Signed.99 * 100 * - `dest`: The recipient of the transfer.101 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all102 * of the funds the account has, causing the sender account to be killed (false), or103 * transfer everything except at least the existential deposit, which will guarantee to104 * keep the sender account alive (true). # <weight>105 * - O(1). Just like transfer, but reading the user's transferable balance first.106 * #</weight>107 **/108 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;109 /**110 * Same as the [`transfer`] call, but with a check that the transfer will not kill the111 * origin account.112 * 113 * 99% of the time you want [`transfer`] instead.114 * 115 * [`transfer`]: struct.Pallet.html#method.transfer116 **/117 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>]>;118 /**119 * Generic tx120 **/121 [key: string]: SubmittableExtrinsicFunction<ApiType>;122 };123 charging: {124 /**125 * Generic tx126 **/127 [key: string]: SubmittableExtrinsicFunction<ApiType>;128 };129 configuration: {130 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;131 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;132 /**133 * Generic tx134 **/135 [key: string]: SubmittableExtrinsicFunction<ApiType>;136 };137 cumulusXcm: {138 /**139 * Generic tx140 **/141 [key: string]: SubmittableExtrinsicFunction<ApiType>;142 };143 dmpQueue: {144 /**145 * Service a single overweight message.146 * 147 * - `origin`: Must pass `ExecuteOverweightOrigin`.148 * - `index`: The index of the overweight message to service.149 * - `weight_limit`: The amount of weight that message execution may take.150 * 151 * Errors:152 * - `Unknown`: Message of `index` is unknown.153 * - `OverLimit`: Message execution may use greater than `weight_limit`.154 * 155 * Events:156 * - `OverweightServiced`: On success.157 **/158 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;159 /**160 * Generic tx161 **/162 [key: string]: SubmittableExtrinsicFunction<ApiType>;163 };164 ethereum: {165 /**166 * Transact an Ethereum transaction.167 **/168 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;169 /**170 * Generic tx171 **/172 [key: string]: SubmittableExtrinsicFunction<ApiType>;173 };174 evm: {175 /**176 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.177 **/178 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>]>>]>;179 /**180 * Issue an EVM create operation. This is similar to a contract creation transaction in181 * Ethereum.182 **/183 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>]>>]>;184 /**185 * Issue an EVM create2 operation.186 **/187 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>]>>]>;188 /**189 * Withdraw balance from EVM into currency/balances pallet.190 **/191 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;192 /**193 * Generic tx194 **/195 [key: string]: SubmittableExtrinsicFunction<ApiType>;196 };197 evmMigration: {198 /**199 * Start contract migration, inserts contract stub at target address,200 * and marks account as pending, allowing to insert storage201 **/202 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;203 /**204 * Finish contract migration, allows it to be called.205 * It is not possible to alter contract storage via [`Self::set_data`]206 * after this call.207 **/208 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;209 /**210 * Insert items into contract storage, this method can be called211 * multiple times212 **/213 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;214 /**215 * Generic tx216 **/217 [key: string]: SubmittableExtrinsicFunction<ApiType>;218 };219 foreignAssets: {220 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]>;221 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]>;222 /**223 * Generic tx224 **/225 [key: string]: SubmittableExtrinsicFunction<ApiType>;226 };227 inflation: {228 /**229 * This method sets the inflation start date. Can be only called once.230 * Inflation start block can be backdated and will catch up. The method will create Treasury231 * account if it does not exist and perform the first inflation deposit.232 * 233 * # Permissions234 * 235 * * Root236 * 237 * # Arguments238 * 239 * * inflation_start_relay_block: The relay chain block at which inflation should start240 **/241 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;242 /**243 * Generic tx244 **/245 [key: string]: SubmittableExtrinsicFunction<ApiType>;246 };247 parachainSystem: {248 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;249 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;250 /**251 * Set the current validation data.252 * 253 * This should be invoked exactly once per block. It will panic at the finalization254 * phase if the call was not invoked.255 * 256 * The dispatch origin for this call must be `Inherent`257 * 258 * As a side effect, this function upgrades the current validation function259 * if the appropriate time has come.260 **/261 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;262 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;263 /**264 * Generic tx265 **/266 [key: string]: SubmittableExtrinsicFunction<ApiType>;267 };268 polkadotXcm: {269 /**270 * Execute an XCM message from a local, signed, origin.271 * 272 * An event is deposited indicating whether `msg` could be executed completely or only273 * partially.274 * 275 * No more than `max_weight` will be used in its attempted execution. If this is less than the276 * maximum amount of weight that the message could take to be executed, then no execution277 * attempt will be made.278 * 279 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully280 * to completion; only that *some* of it was executed.281 **/282 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;283 /**284 * Set a safe XCM version (the version that XCM should be encoded with if the most recent285 * version a destination can accept is unknown).286 * 287 * - `origin`: Must be Root.288 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.289 **/290 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;291 /**292 * Ask a location to notify us regarding their XCM version and any changes to it.293 * 294 * - `origin`: Must be Root.295 * - `location`: The location to which we should subscribe for XCM version notifications.296 **/297 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;298 /**299 * Require that a particular destination should no longer notify us regarding any XCM300 * version changes.301 * 302 * - `origin`: Must be Root.303 * - `location`: The location to which we are currently subscribed for XCM version304 * notifications which we no longer desire.305 **/306 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;307 /**308 * Extoll that a particular destination can be communicated with through a particular309 * version of XCM.310 * 311 * - `origin`: Must be Root.312 * - `location`: The destination that is being described.313 * - `xcm_version`: The latest version of XCM that `location` supports.314 **/315 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;316 /**317 * Transfer some assets from the local chain to the sovereign account of a destination318 * chain and forward a notification XCM.319 * 320 * Fee payment on the destination side is made from the asset in the `assets` vector of321 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight322 * is needed than `weight_limit`, then the operation will fail and the assets send may be323 * at risk.324 * 325 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.326 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send327 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.328 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be329 * an `AccountId32` value.330 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the331 * `dest` side.332 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay333 * fees.334 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.335 **/336 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]>;337 /**338 * Teleport some assets from the local chain to some destination chain.339 * 340 * Fee payment on the destination side is made from the asset in the `assets` vector of341 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight342 * is needed than `weight_limit`, then the operation will fail and the assets send may be343 * at risk.344 * 345 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.346 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send347 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.348 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be349 * an `AccountId32` value.350 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the351 * `dest` side. May not be empty.352 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay353 * fees.354 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.355 **/356 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]>;357 /**358 * Transfer some assets from the local chain to the sovereign account of a destination359 * chain and forward a notification XCM.360 * 361 * Fee payment on the destination side is made from the asset in the `assets` vector of362 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,363 * with all fees taken as needed from the asset.364 * 365 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.366 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send367 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.368 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be369 * an `AccountId32` value.370 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the371 * `dest` side.372 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay373 * fees.374 **/375 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]>;376 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;377 /**378 * Teleport some assets from the local chain to some destination chain.379 * 380 * Fee payment on the destination side is made from the asset in the `assets` vector of381 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,382 * with all fees taken as needed from the asset.383 * 384 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.385 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send386 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.387 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be388 * an `AccountId32` value.389 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the390 * `dest` side. May not be empty.391 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay392 * fees.393 **/394 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]>;395 /**396 * Generic tx397 **/398 [key: string]: SubmittableExtrinsicFunction<ApiType>;399 };400 rmrkCore: {401 /**402 * Accept an NFT sent from another account to self or an owned NFT.403 * 404 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.405 * 406 * # Permissions:407 * - Token-owner-to-be408 * 409 * # Arguments:410 * - `origin`: sender of the transaction411 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.412 * - `rmrk_nft_id`: ID of the NFT to be accepted.413 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,414 * whichever the accepted NFT was sent to.415 **/416 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;417 /**418 * Accept the addition of a newly created pending resource to an existing NFT.419 * 420 * This transaction is needed when a resource is created and assigned to an NFT421 * by a non-owner, i.e. the collection issuer, with one of the422 * [`add_...` transactions](Pallet::add_basic_resource).423 * 424 * # Permissions:425 * - Token owner426 * 427 * # Arguments:428 * - `origin`: sender of the transaction429 * - `rmrk_collection_id`: RMRK collection ID of the NFT.430 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.431 * - `resource_id`: ID of the newly created pending resource.432 * accept the addition of a new resource to an existing NFT433 **/434 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;435 /**436 * Accept the removal of a removal-pending resource from an NFT.437 * 438 * This transaction is needed when a non-owner, i.e. the collection issuer,439 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.440 * 441 * # Permissions:442 * - Token owner443 * 444 * # Arguments:445 * - `origin`: sender of the transaction446 * - `rmrk_collection_id`: RMRK collection ID of the NFT.447 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.448 * - `resource_id`: ID of the removal-pending resource.449 **/450 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;451 /**452 * Create and set/propose a basic resource for an NFT.453 * 454 * A basic resource is the simplest, lacking a Base and anything that comes with it.455 * See RMRK docs for more information and examples.456 * 457 * # Permissions:458 * - Collection issuer - if not the token owner, adding the resource will warrant459 * the owner's [acceptance](Pallet::accept_resource).460 * 461 * # Arguments:462 * - `origin`: sender of the transaction463 * - `rmrk_collection_id`: RMRK collection ID of the NFT.464 * - `nft_id`: ID of the NFT to assign a resource to.465 * - `resource`: Data of the resource to be created.466 **/467 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]>;468 /**469 * Create and set/propose a composable resource for an NFT.470 * 471 * A composable resource links to a Base and has a subset of its Parts it is composed of.472 * See RMRK docs for more information and examples.473 * 474 * # Permissions:475 * - Collection issuer - if not the token owner, adding the resource will warrant476 * the owner's [acceptance](Pallet::accept_resource).477 * 478 * # Arguments:479 * - `origin`: sender of the transaction480 * - `rmrk_collection_id`: RMRK collection ID of the NFT.481 * - `nft_id`: ID of the NFT to assign a resource to.482 * - `resource`: Data of the resource to be created.483 **/484 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]>;485 /**486 * Create and set/propose a slot resource for an NFT.487 * 488 * A slot resource links to a Base and a slot ID in it which it can fit into.489 * See RMRK docs for more information and examples.490 * 491 * # Permissions:492 * - Collection issuer - if not the token owner, adding the resource will warrant493 * the owner's [acceptance](Pallet::accept_resource).494 * 495 * # Arguments:496 * - `origin`: sender of the transaction497 * - `rmrk_collection_id`: RMRK collection ID of the NFT.498 * - `nft_id`: ID of the NFT to assign a resource to.499 * - `resource`: Data of the resource to be created.500 **/501 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]>;502 /**503 * Burn an NFT, destroying it and its nested tokens up to the specified limit.504 * If the burning budget is exceeded, the transaction is reverted.505 * 506 * This is the way to burn a nested token as well.507 * 508 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).509 * 510 * # Permissions:511 * * Token owner512 * 513 * # Arguments:514 * - `origin`: sender of the transaction515 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.516 * - `nft_id`: ID of the NFT to be destroyed.517 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction518 * is reverted if there are more tokens to burn in the nesting tree than this number.519 * This is primarily a mechanism of transaction weight control.520 **/521 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;522 /**523 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).524 * 525 * # Permissions:526 * * Collection issuer527 * 528 * # Arguments:529 * - `origin`: sender of the transaction530 * - `collection_id`: RMRK collection ID to change the issuer of.531 * - `new_issuer`: Collection's new issuer.532 **/533 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;534 /**535 * Create a new collection of NFTs.536 * 537 * # Permissions:538 * * Anyone - will be assigned as the issuer of the collection.539 * 540 * # Arguments:541 * - `origin`: sender of the transaction542 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.543 * - `max`: Optional maximum number of tokens.544 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.545 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.546 **/547 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;548 /**549 * Destroy a collection.550 * 551 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.552 * 553 * # Permissions:554 * * Collection issuer555 * 556 * # Arguments:557 * - `origin`: sender of the transaction558 * - `collection_id`: RMRK ID of the collection to destroy.559 **/560 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;561 /**562 * "Lock" the collection and prevent new token creation. Cannot be undone.563 * 564 * # Permissions:565 * * Collection issuer566 * 567 * # Arguments:568 * - `origin`: sender of the transaction569 * - `collection_id`: RMRK ID of the collection to lock.570 **/571 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;572 /**573 * Mint an NFT in a specified collection.574 * 575 * # Permissions:576 * * Collection issuer577 * 578 * # Arguments:579 * - `origin`: sender of the transaction580 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).581 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.582 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.583 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.584 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.585 * - `transferable`: Can this NFT be transferred? Cannot be changed.586 * - `resources`: Resource data to be added to the NFT immediately after minting.587 **/588 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>>]>;589 /**590 * Reject an NFT sent from another account to self or owned NFT.591 * The NFT in question will not be sent back and burnt instead.592 * 593 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.594 * 595 * # Permissions:596 * - Token-owner-to-be-not597 * 598 * # Arguments:599 * - `origin`: sender of the transaction600 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.601 * - `rmrk_nft_id`: ID of the NFT to be rejected.602 **/603 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;604 /**605 * Remove and erase a resource from an NFT.606 * 607 * If the sender does not own the NFT, then it will be pending confirmation,608 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.609 * 610 * # Permissions611 * - Collection issuer612 * 613 * # Arguments614 * - `origin`: sender of the transaction615 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.616 * - `nft_id`: ID of the NFT with a resource to be removed.617 * - `resource_id`: ID of the resource to be removed.618 **/619 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;620 /**621 * Transfer an NFT from an account/NFT A to another account/NFT B.622 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].623 * 624 * If the target owner is an NFT owned by another account, then the NFT will enter625 * the pending state and will have to be accepted by the other account.626 * 627 * # Permissions:628 * - Token owner629 * 630 * # Arguments:631 * - `origin`: sender of the transaction632 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.633 * - `rmrk_nft_id`: ID of the NFT to be transferred.634 * - `new_owner`: New owner of the nft which can be either an account or a NFT.635 **/636 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;637 /**638 * Set a different order of resource priorities for an NFT. Priorities can be used,639 * for example, for order of rendering.640 * 641 * Note that the priorities are not updated automatically, and are an empty vector642 * by default. There is no pre-set definition for the order to be particular,643 * it can be interpreted arbitrarily use-case by use-case.644 * 645 * # Permissions:646 * - Token owner647 * 648 * # Arguments:649 * - `origin`: sender of the transaction650 * - `rmrk_collection_id`: RMRK collection ID of the NFT.651 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.652 * - `priorities`: Ordered vector of resource IDs.653 **/654 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;655 /**656 * Add or edit a custom user property, a key-value pair, describing the metadata657 * of a token or a collection, on either one of these.658 * 659 * Note that in this proxy implementation many details regarding RMRK are stored660 * as scoped properties prefixed with "rmrk:", normally inaccessible661 * to external transactions and RPCs.662 * 663 * # Permissions:664 * - Collection issuer - in case of collection property665 * - Token owner - in case of NFT property666 * 667 * # Arguments:668 * - `origin`: sender of the transaction669 * - `rmrk_collection_id`: RMRK collection ID.670 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.671 * - `key`: Key of the custom property to be referenced by.672 * - `value`: Value of the custom property to be stored.673 **/674 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]>;675 /**676 * Generic tx677 **/678 [key: string]: SubmittableExtrinsicFunction<ApiType>;679 };680 rmrkEquip: {681 /**682 * Create a new Base.683 * 684 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)685 * 686 * # Permissions687 * - Anyone - will be assigned as the issuer of the Base.688 * 689 * # Arguments:690 * - `origin`: Caller, will be assigned as the issuer of the Base691 * - `base_type`: Arbitrary media type, e.g. "svg".692 * - `symbol`: Arbitrary client-chosen symbol.693 * - `parts`: Array of Fixed and Slot Parts composing the Base,694 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).695 **/696 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>]>;697 /**698 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.699 * 700 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).701 * 702 * # Permissions:703 * - Base issuer704 * 705 * # Arguments:706 * - `origin`: sender of the transaction707 * - `base_id`: Base containing the Slot Part to be updated.708 * - `slot_id`: Slot Part whose Equippable List is being updated .709 * - `equippables`: List of equippables that will override the current Equippables list.710 **/711 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]>;712 /**713 * Add a Theme to a Base.714 * A Theme named "default" is required prior to adding other Themes.715 * 716 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).717 * 718 * # Permissions:719 * - Base issuer720 * 721 * # Arguments:722 * - `origin`: sender of the transaction723 * - `base_id`: Base ID containing the Theme to be updated.724 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an725 * array of [key, value, inherit].726 * - `key`: Arbitrary BoundedString, defined by client.727 * - `value`: Arbitrary BoundedString, defined by client.728 * - `inherit`: Optional bool.729 **/730 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;731 /**732 * Generic tx733 **/734 [key: string]: SubmittableExtrinsicFunction<ApiType>;735 };736 scheduler: {737 /**738 * Cancel a named scheduled task.739 **/740 cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;741 /**742 * Schedule a named task.743 **/744 scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;745 /**746 * Schedule a named task after a delay.747 * 748 * # <weight>749 * Same as [`schedule_named`](Self::schedule_named).750 * # </weight>751 **/752 scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, FrameSupportScheduleMaybeHashed]>;753 /**754 * Generic tx755 **/756 [key: string]: SubmittableExtrinsicFunction<ApiType>;757 };758 structure: {759 /**760 * Generic tx761 **/762 [key: string]: SubmittableExtrinsicFunction<ApiType>;763 };764 sudo: {765 /**766 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo767 * key.768 * 769 * The dispatch origin for this call must be _Signed_.770 * 771 * # <weight>772 * - O(1).773 * - Limited storage reads.774 * - One DB change.775 * # </weight>776 **/777 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;778 /**779 * Authenticates the sudo key and dispatches a function call with `Root` origin.780 * 781 * The dispatch origin for this call must be _Signed_.782 * 783 * # <weight>784 * - O(1).785 * - Limited storage reads.786 * - One DB write (event).787 * - Weight of derivative `call` execution + 10,000.788 * # </weight>789 **/790 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;791 /**792 * Authenticates the sudo key and dispatches a function call with `Signed` origin from793 * a given account.794 * 795 * The dispatch origin for this call must be _Signed_.796 * 797 * # <weight>798 * - O(1).799 * - Limited storage reads.800 * - One DB write (event).801 * - Weight of derivative `call` execution + 10,000.802 * # </weight>803 **/804 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]>;805 /**806 * Authenticates the sudo key and dispatches a function call with `Root` origin.807 * This function does not check the weight of the call, and instead allows the808 * Sudo user to specify the weight of the call.809 * 810 * The dispatch origin for this call must be _Signed_.811 * 812 * # <weight>813 * - O(1).814 * - The weight of this call is defined by the caller.815 * # </weight>816 **/817 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;818 /**819 * Generic tx820 **/821 [key: string]: SubmittableExtrinsicFunction<ApiType>;822 };823 system: {824 /**825 * A dispatch that will fill the block weight up to the given ratio.826 **/827 fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;828 /**829 * Kill all storage items with a key that starts with the given prefix.830 * 831 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under832 * the prefix we are removing to accurately calculate the weight of this function.833 **/834 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;835 /**836 * Kill some items from storage.837 **/838 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;839 /**840 * Make some on-chain remark.841 * 842 * # <weight>843 * - `O(1)`844 * # </weight>845 **/846 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;847 /**848 * Make some on-chain remark and emit event.849 **/850 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;851 /**852 * Set the new runtime code.853 * 854 * # <weight>855 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`856 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is857 * expensive).858 * - 1 storage write (codec `O(C)`).859 * - 1 digest item.860 * - 1 event.861 * The weight of this function is dependent on the runtime, but generally this is very862 * expensive. We will treat this as a full block.863 * # </weight>864 **/865 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;866 /**867 * Set the new runtime code without doing any checks of the given `code`.868 * 869 * # <weight>870 * - `O(C)` where `C` length of `code`871 * - 1 storage write (codec `O(C)`).872 * - 1 digest item.873 * - 1 event.874 * The weight of this function is dependent on the runtime. We will treat this as a full875 * block. # </weight>876 **/877 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;878 /**879 * Set the number of pages in the WebAssembly environment's heap.880 **/881 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;882 /**883 * Set some items of storage.884 **/885 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;886 /**887 * Generic tx888 **/889 [key: string]: SubmittableExtrinsicFunction<ApiType>;890 };891 timestamp: {892 /**893 * Set the current time.894 * 895 * This call should be invoked exactly once per block. It will panic at the finalization896 * phase, if this call hasn't been invoked by that time.897 * 898 * The timestamp should be greater than the previous one by the amount specified by899 * `MinimumPeriod`.900 * 901 * The dispatch origin for this call must be `Inherent`.902 * 903 * # <weight>904 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)905 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in906 * `on_finalize`)907 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.908 * # </weight>909 **/910 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;911 /**912 * Generic tx913 **/914 [key: string]: SubmittableExtrinsicFunction<ApiType>;915 };916 tokens: {917 /**918 * Exactly as `transfer`, except the origin must be root and the source919 * account may be specified.920 * 921 * The dispatch origin for this call must be _Root_.922 * 923 * - `source`: The sender of the transfer.924 * - `dest`: The recipient of the transfer.925 * - `currency_id`: currency type.926 * - `amount`: free balance amount to tranfer.927 **/928 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>]>;929 /**930 * Set the balances of a given account.931 * 932 * This will alter `FreeBalance` and `ReservedBalance` in storage. it933 * will also decrease the total issuance of the system934 * (`TotalIssuance`). If the new free or reserved balance is below the935 * existential deposit, it will reap the `AccountInfo`.936 * 937 * The dispatch origin for this call is `root`.938 **/939 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>]>;940 /**941 * Transfer some liquid free balance to another account.942 * 943 * `transfer` will set the `FreeBalance` of the sender and receiver.944 * It will decrease the total issuance of the system by the945 * `TransferFee`. If the sender's account is below the existential946 * deposit as a result of the transfer, the account will be reaped.947 * 948 * The dispatch origin for this call must be `Signed` by the949 * transactor.950 * 951 * - `dest`: The recipient of the transfer.952 * - `currency_id`: currency type.953 * - `amount`: free balance amount to tranfer.954 **/955 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>]>;956 /**957 * Transfer all remaining balance to the given account.958 * 959 * NOTE: This function only attempts to transfer _transferable_960 * balances. This means that any locked, reserved, or existential961 * deposits (when `keep_alive` is `true`), will not be transferred by962 * this function. To ensure that this function results in a killed963 * account, you might need to prepare the account by removing any964 * reference counters, storage deposits, etc...965 * 966 * The dispatch origin for this call must be `Signed` by the967 * transactor.968 * 969 * - `dest`: The recipient of the transfer.970 * - `currency_id`: currency type.971 * - `keep_alive`: A boolean to determine if the `transfer_all`972 * operation should send all of the funds the account has, causing973 * the sender account to be killed (false), or transfer everything974 * except at least the existential deposit, which will guarantee to975 * keep the sender account alive (true).976 **/977 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]>;978 /**979 * Same as the [`transfer`] call, but with a check that the transfer980 * will not kill the origin account.981 * 982 * 99% of the time you want [`transfer`] instead.983 * 984 * The dispatch origin for this call must be `Signed` by the985 * transactor.986 * 987 * - `dest`: The recipient of the transfer.988 * - `currency_id`: currency type.989 * - `amount`: free balance amount to tranfer.990 **/991 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>]>;992 /**993 * Generic tx994 **/995 [key: string]: SubmittableExtrinsicFunction<ApiType>;996 };997 treasury: {998 /**999 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1000 * and the original deposit will be returned.1001 * 1002 * May only be called from `T::ApproveOrigin`.1003 * 1004 * # <weight>1005 * - Complexity: O(1).1006 * - DbReads: `Proposals`, `Approvals`1007 * - DbWrite: `Approvals`1008 * # </weight>1009 **/1010 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1011 /**1012 * Put forward a suggestion for spending. A deposit proportional to the value1013 * is reserved and slashed if the proposal is rejected. It is returned once the1014 * proposal is awarded.1015 * 1016 * # <weight>1017 * - Complexity: O(1)1018 * - DbReads: `ProposalCount`, `origin account`1019 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1020 * # </weight>1021 **/1022 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]>;1023 /**1024 * Reject a proposed spend. The original deposit will be slashed.1025 * 1026 * May only be called from `T::RejectOrigin`.1027 * 1028 * # <weight>1029 * - Complexity: O(1)1030 * - DbReads: `Proposals`, `rejected proposer account`1031 * - DbWrites: `Proposals`, `rejected proposer account`1032 * # </weight>1033 **/1034 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1035 /**1036 * Force a previously approved proposal to be removed from the approval queue.1037 * The original deposit will no longer be returned.1038 * 1039 * May only be called from `T::RejectOrigin`.1040 * - `proposal_id`: The index of a proposal1041 * 1042 * # <weight>1043 * - Complexity: O(A) where `A` is the number of approvals1044 * - Db reads and writes: `Approvals`1045 * # </weight>1046 * 1047 * Errors:1048 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1049 * i.e., the proposal has not been approved. This could also mean the proposal does not1050 * exist altogether, thus there is no way it would have been approved in the first place.1051 **/1052 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1053 /**1054 * Propose and approve a spend of treasury funds.1055 * 1056 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1057 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1058 * - `beneficiary`: The destination account for the transfer.1059 * 1060 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1061 * beneficiary.1062 **/1063 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]>;1064 /**1065 * Generic tx1066 **/1067 [key: string]: SubmittableExtrinsicFunction<ApiType>;1068 };1069 unique: {1070 /**1071 * Add an admin to a collection.1072 * 1073 * NFT Collection can be controlled by multiple admin addresses1074 * (some which can also be servers, for example). Admins can issue1075 * and burn NFTs, as well as add and remove other admins,1076 * but cannot change NFT or Collection ownership.1077 * 1078 * # Permissions1079 * 1080 * * Collection owner1081 * * Collection admin1082 * 1083 * # Arguments1084 * 1085 * * `collection_id`: ID of the Collection to add an admin for.1086 * * `new_admin`: Address of new admin to add.1087 **/1088 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1089 /**1090 * Add an address to allow list.1091 * 1092 * # Permissions1093 * 1094 * * Collection owner1095 * * Collection admin1096 * 1097 * # Arguments1098 * 1099 * * `collection_id`: ID of the modified collection.1100 * * `address`: ID of the address to be added to the allowlist.1101 **/1102 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1103 /**1104 * Allow a non-permissioned address to transfer or burn an item.1105 * 1106 * # Permissions1107 * 1108 * * Collection owner1109 * * Collection admin1110 * * Current item owner1111 * 1112 * # Arguments1113 * 1114 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1115 * * `collection_id`: ID of the collection the item belongs to.1116 * * `item_id`: ID of the item transactions on which are now approved.1117 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1118 * Set to 0 to revoke the approval.1119 **/1120 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]>;1121 /**1122 * Destroy a token on behalf of the owner as a non-owner account.1123 * 1124 * See also: [`approve`][`Pallet::approve`].1125 * 1126 * After this method executes, one approval is removed from the total so that1127 * the approved address will not be able to transfer this item again from this owner.1128 * 1129 * # Permissions1130 * 1131 * * Collection owner1132 * * Collection admin1133 * * Current token owner1134 * * Address approved by current item owner1135 * 1136 * # Arguments1137 * 1138 * * `from`: The owner of the burning item.1139 * * `collection_id`: ID of the collection to which the item belongs.1140 * * `item_id`: ID of item to burn.1141 * * `value`: Number of pieces to burn.1142 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1143 * * Fungible Mode: The desired number of pieces to burn.1144 * * Re-Fungible Mode: The desired number of pieces to burn.1145 **/1146 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]>;1147 /**1148 * Destroy an item.1149 * 1150 * # Permissions1151 * 1152 * * Collection owner1153 * * Collection admin1154 * * Current item owner1155 * 1156 * # Arguments1157 * 1158 * * `collection_id`: ID of the collection to which the item belongs.1159 * * `item_id`: ID of item to burn.1160 * * `value`: Number of pieces of the item to destroy.1161 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1162 * * Fungible Mode: The desired number of pieces to burn.1163 * * Re-Fungible Mode: The desired number of pieces to burn.1164 **/1165 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1166 /**1167 * Change the owner of the collection.1168 * 1169 * # Permissions1170 * 1171 * * Collection owner1172 * 1173 * # Arguments1174 * 1175 * * `collection_id`: ID of the modified collection.1176 * * `new_owner`: ID of the account that will become the owner.1177 **/1178 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1179 /**1180 * Confirm own sponsorship of a collection, becoming the sponsor.1181 * 1182 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1183 * Sponsor can pay the fees of a transaction instead of the sender,1184 * but only within specified limits.1185 * 1186 * # Permissions1187 * 1188 * * Sponsor-to-be1189 * 1190 * # Arguments1191 * 1192 * * `collection_id`: ID of the collection with the pending sponsor.1193 **/1194 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1195 /**1196 * Create a collection of tokens.1197 * 1198 * Each Token may have multiple properties encoded as an array of bytes1199 * of certain length. The initial owner of the collection is set1200 * to the address that signed the transaction and can be changed later.1201 * 1202 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1203 * 1204 * # Permissions1205 * 1206 * * Anyone - becomes the owner of the new collection.1207 * 1208 * # Arguments1209 * 1210 * * `collection_name`: Wide-character string with collection name1211 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1212 * * `collection_description`: Wide-character string with collection description1213 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1214 * * `token_prefix`: Byte string containing the token prefix to mark a collection1215 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1216 * * `mode`: Type of items stored in the collection and type dependent data.1217 **/1218 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]>;1219 /**1220 * Create a collection with explicit parameters.1221 * 1222 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1223 * 1224 * # Permissions1225 * 1226 * * Anyone - becomes the owner of the new collection.1227 * 1228 * # Arguments1229 * 1230 * * `data`: Explicit data of a collection used for its creation.1231 **/1232 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]>;1233 /**1234 * Mint an item within a collection.1235 * 1236 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1237 * 1238 * # Permissions1239 * 1240 * * Collection owner1241 * * Collection admin1242 * * Anyone if1243 * * Allow List is enabled, and1244 * * Address is added to allow list, and1245 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1246 * 1247 * # Arguments1248 * 1249 * * `collection_id`: ID of the collection to which an item would belong.1250 * * `owner`: Address of the initial owner of the item.1251 * * `data`: Token data describing the item to store on chain.1252 **/1253 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]>;1254 /**1255 * Create multiple items within a collection.1256 * 1257 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1258 * 1259 * # Permissions1260 * 1261 * * Collection owner1262 * * Collection admin1263 * * Anyone if1264 * * Allow List is enabled, and1265 * * Address is added to the allow list, and1266 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1267 * 1268 * # Arguments1269 * 1270 * * `collection_id`: ID of the collection to which the tokens would belong.1271 * * `owner`: Address of the initial owner of the tokens.1272 * * `items_data`: Vector of data describing each item to be created.1273 **/1274 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>]>;1275 /**1276 * Create multiple items within a collection with explicitly specified initial parameters.1277 * 1278 * # Permissions1279 * 1280 * * Collection owner1281 * * Collection admin1282 * * Anyone if1283 * * Allow List is enabled, and1284 * * Address is added to allow list, and1285 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1286 * 1287 * # Arguments1288 * 1289 * * `collection_id`: ID of the collection to which the tokens would belong.1290 * * `data`: Explicit item creation data.1291 **/1292 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1293 /**1294 * Delete specified collection properties.1295 * 1296 * # Permissions1297 * 1298 * * Collection Owner1299 * * Collection Admin1300 * 1301 * # Arguments1302 * 1303 * * `collection_id`: ID of the modified collection.1304 * * `property_keys`: Vector of keys of the properties to be deleted.1305 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1306 **/1307 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1308 /**1309 * Delete specified token properties. Currently properties only work with NFTs.1310 * 1311 * # Permissions1312 * 1313 * * Depends on collection's token property permissions and specified property mutability:1314 * * Collection owner1315 * * Collection admin1316 * * Token owner1317 * 1318 * # Arguments1319 * 1320 * * `collection_id`: ID of the collection to which the token belongs.1321 * * `token_id`: ID of the modified token.1322 * * `property_keys`: Vector of keys of the properties to be deleted.1323 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1324 **/1325 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1326 /**1327 * Destroy a collection if no tokens exist within.1328 * 1329 * # Permissions1330 * 1331 * * Collection owner1332 * 1333 * # Arguments1334 * 1335 * * `collection_id`: Collection to destroy.1336 **/1337 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1338 /**1339 * Remove admin of a collection.1340 * 1341 * An admin address can remove itself. List of admins may become empty,1342 * in which case only Collection Owner will be able to add an Admin.1343 * 1344 * # Permissions1345 * 1346 * * Collection owner1347 * * Collection admin1348 * 1349 * # Arguments1350 * 1351 * * `collection_id`: ID of the collection to remove the admin for.1352 * * `account_id`: Address of the admin to remove.1353 **/1354 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1355 /**1356 * Remove a collection's a sponsor, making everyone pay for their own transactions.1357 * 1358 * # Permissions1359 * 1360 * * Collection owner1361 * 1362 * # Arguments1363 * 1364 * * `collection_id`: ID of the collection with the sponsor to remove.1365 **/1366 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1367 /**1368 * Remove an address from allow list.1369 * 1370 * # Permissions1371 * 1372 * * Collection owner1373 * * Collection admin1374 * 1375 * # Arguments1376 * 1377 * * `collection_id`: ID of the modified collection.1378 * * `address`: ID of the address to be removed from the allowlist.1379 **/1380 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1381 /**1382 * Re-partition a refungible token, while owning all of its parts/pieces.1383 * 1384 * # Permissions1385 * 1386 * * Token owner (must own every part)1387 * 1388 * # Arguments1389 * 1390 * * `collection_id`: ID of the collection the RFT belongs to.1391 * * `token_id`: ID of the RFT.1392 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1393 **/1394 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1395 /**1396 * Set specific limits of a collection. Empty, or None fields mean chain default.1397 * 1398 * # Permissions1399 * 1400 * * Collection owner1401 * * Collection admin1402 * 1403 * # Arguments1404 * 1405 * * `collection_id`: ID of the modified collection.1406 * * `new_limit`: New limits of the collection. Fields that are not set (None)1407 * will not overwrite the old ones.1408 **/1409 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]>;1410 /**1411 * Set specific permissions of a collection. Empty, or None fields mean chain default.1412 * 1413 * # Permissions1414 * 1415 * * Collection owner1416 * * Collection admin1417 * 1418 * # Arguments1419 * 1420 * * `collection_id`: ID of the modified collection.1421 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1422 * will not overwrite the old ones.1423 **/1424 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1425 /**1426 * Add or change collection properties.1427 * 1428 * # Permissions1429 * 1430 * * Collection owner1431 * * Collection admin1432 * 1433 * # Arguments1434 * 1435 * * `collection_id`: ID of the modified collection.1436 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1437 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1438 **/1439 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1440 /**1441 * Set (invite) a new collection sponsor.1442 * 1443 * If successful, confirmation from the sponsor-to-be will be pending.1444 * 1445 * # Permissions1446 * 1447 * * Collection owner1448 * * Collection admin1449 * 1450 * # Arguments1451 * 1452 * * `collection_id`: ID of the modified collection.1453 * * `new_sponsor`: ID of the account of the sponsor-to-be.1454 **/1455 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1456 /**1457 * Add or change token properties according to collection's permissions.1458 * Currently properties only work with NFTs.1459 * 1460 * # Permissions1461 * 1462 * * Depends on collection's token property permissions and specified property mutability:1463 * * Collection owner1464 * * Collection admin1465 * * Token owner1466 * 1467 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1468 * 1469 * # Arguments1470 * 1471 * * `collection_id: ID of the collection to which the token belongs.1472 * * `token_id`: ID of the modified token.1473 * * `properties`: Vector of key-value pairs stored as the token's metadata.1474 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1475 **/1476 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>]>;1477 /**1478 * Add or change token property permissions of a collection.1479 * 1480 * Without a permission for a particular key, a property with that key1481 * cannot be created in a token.1482 * 1483 * # Permissions1484 * 1485 * * Collection owner1486 * * Collection admin1487 * 1488 * # Arguments1489 * 1490 * * `collection_id`: ID of the modified collection.1491 * * `property_permissions`: Vector of permissions for property keys.1492 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1493 **/1494 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1495 /**1496 * Completely allow or disallow transfers for a particular collection.1497 * 1498 * # Permissions1499 * 1500 * * Collection owner1501 * 1502 * # Arguments1503 * 1504 * * `collection_id`: ID of the collection.1505 * * `value`: New value of the flag, are transfers allowed?1506 **/1507 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1508 /**1509 * Change ownership of the token.1510 * 1511 * # Permissions1512 * 1513 * * Collection owner1514 * * Collection admin1515 * * Current token owner1516 * 1517 * # Arguments1518 * 1519 * * `recipient`: Address of token recipient.1520 * * `collection_id`: ID of the collection the item belongs to.1521 * * `item_id`: ID of the item.1522 * * Non-Fungible Mode: Required.1523 * * Fungible Mode: Ignored.1524 * * Re-Fungible Mode: Required.1525 * 1526 * * `value`: Amount to transfer.1527 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1528 * * Fungible Mode: The desired number of pieces to transfer.1529 * * Re-Fungible Mode: The desired number of pieces to transfer.1530 **/1531 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]>;1532 /**1533 * Change ownership of an item on behalf of the owner as a non-owner account.1534 * 1535 * See the [`approve`][`Pallet::approve`] method for additional information.1536 * 1537 * After this method executes, one approval is removed from the total so that1538 * the approved address will not be able to transfer this item again from this owner.1539 * 1540 * # Permissions1541 * 1542 * * Collection owner1543 * * Collection admin1544 * * Current item owner1545 * * Address approved by current item owner1546 * 1547 * # Arguments1548 * 1549 * * `from`: Address that currently owns the token.1550 * * `recipient`: Address of the new token-owner-to-be.1551 * * `collection_id`: ID of the collection the item.1552 * * `item_id`: ID of the item to be transferred.1553 * * `value`: Amount to transfer.1554 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1555 * * Fungible Mode: The desired number of pieces to transfer.1556 * * Re-Fungible Mode: The desired number of pieces to transfer.1557 **/1558 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]>;1559 /**1560 * Generic tx1561 **/1562 [key: string]: SubmittableExtrinsicFunction<ApiType>;1563 };1564 vesting: {1565 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1566 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1567 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>]>;1568 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]>;1569 /**1570 * Generic tx1571 **/1572 [key: string]: SubmittableExtrinsicFunction<ApiType>;1573 };1574 xcmpQueue: {1575 /**1576 * Resumes all XCM executions for the XCMP queue.1577 * 1578 * Note that this function doesn't change the status of the in/out bound channels.1579 * 1580 * - `origin`: Must pass `ControllerOrigin`.1581 **/1582 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1583 /**1584 * Services a single overweight XCM.1585 * 1586 * - `origin`: Must pass `ExecuteOverweightOrigin`.1587 * - `index`: The index of the overweight XCM to service1588 * - `weight_limit`: The amount of weight that XCM execution may take.1589 * 1590 * Errors:1591 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1592 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1593 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1594 * 1595 * Events:1596 * - `OverweightServiced`: On success.1597 **/1598 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1599 /**1600 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1601 * 1602 * - `origin`: Must pass `ControllerOrigin`.1603 **/1604 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1605 /**1606 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1607 * messages from the channel.1608 * 1609 * - `origin`: Must pass `Root`.1610 * - `new`: Desired value for `QueueConfigData.drop_threshold`1611 **/1612 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1613 /**1614 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1615 * message sending may recommence after it has been suspended.1616 * 1617 * - `origin`: Must pass `Root`.1618 * - `new`: Desired value for `QueueConfigData.resume_threshold`1619 **/1620 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1621 /**1622 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1623 * suspend their sending.1624 * 1625 * - `origin`: Must pass `Root`.1626 * - `new`: Desired value for `QueueConfigData.suspend_value`1627 **/1628 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1629 /**1630 * Overwrites the amount of remaining weight under which we stop processing messages.1631 * 1632 * - `origin`: Must pass `Root`.1633 * - `new`: Desired value for `QueueConfigData.threshold_weight`1634 **/1635 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1636 /**1637 * Overwrites the speed to which the available weight approaches the maximum weight.1638 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1639 * 1640 * - `origin`: Must pass `Root`.1641 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1642 **/1643 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1644 /**1645 * Overwrite the maximum amount of weight any individual message may consume.1646 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1647 * 1648 * - `origin`: Must pass `Root`.1649 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1650 **/1651 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1652 /**1653 * Generic tx1654 **/1655 [key: string]: SubmittableExtrinsicFunction<ApiType>;1656 };1657 xTokens: {1658 /**1659 * Transfer native currencies.1660 * 1661 * `dest_weight` is the weight for XCM execution on the dest chain, and1662 * it would be charged from the transferred assets. If set below1663 * requirements, the execution may fail and assets wouldn't be1664 * received.1665 * 1666 * It's a no-op if any error on local XCM execution or message sending.1667 * Note sending assets out per se doesn't guarantee they would be1668 * received. Receiving depends on if the XCM message could be delivered1669 * by the network, and if the receiving chain would handle1670 * messages correctly.1671 **/1672 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]>;1673 /**1674 * Transfer `MultiAsset`.1675 * 1676 * `dest_weight` is the weight for XCM execution on the dest chain, and1677 * it would be charged from the transferred assets. If set below1678 * requirements, the execution may fail and assets wouldn't be1679 * received.1680 * 1681 * It's a no-op if any error on local XCM execution or message sending.1682 * Note sending assets out per se doesn't guarantee they would be1683 * received. Receiving depends on if the XCM message could be delivered1684 * by the network, and if the receiving chain would handle1685 * messages correctly.1686 **/1687 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]>;1688 /**1689 * Transfer several `MultiAsset` specifying the item to be used as fee1690 * 1691 * `dest_weight` is the weight for XCM execution on the dest chain, and1692 * it would be charged from the transferred assets. If set below1693 * requirements, the execution may fail and assets wouldn't be1694 * received.1695 * 1696 * `fee_item` is index of the MultiAssets that we want to use for1697 * payment1698 * 1699 * It's a no-op if any error on local XCM execution or message sending.1700 * Note sending assets out per se doesn't guarantee they would be1701 * received. Receiving depends on if the XCM message could be delivered1702 * by the network, and if the receiving chain would handle1703 * messages correctly.1704 **/1705 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]>;1706 /**1707 * Transfer `MultiAsset` specifying the fee and amount as separate.1708 * 1709 * `dest_weight` is the weight for XCM execution on the dest chain, and1710 * it would be charged from the transferred assets. If set below1711 * requirements, the execution may fail and assets wouldn't be1712 * received.1713 * 1714 * `fee` is the multiasset to be spent to pay for execution in1715 * destination chain. Both fee and amount will be subtracted form the1716 * callers balance For now we only accept fee and asset having the same1717 * `MultiLocation` id.1718 * 1719 * If `fee` is not high enough to cover for the execution costs in the1720 * destination chain, then the assets will be trapped in the1721 * destination chain1722 * 1723 * It's a no-op if any error on local XCM execution or message sending.1724 * Note sending assets out per se doesn't guarantee they would be1725 * received. Receiving depends on if the XCM message could be delivered1726 * by the network, and if the receiving chain would handle1727 * messages correctly.1728 **/1729 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]>;1730 /**1731 * Transfer several currencies specifying the item to be used as fee1732 * 1733 * `dest_weight` is the weight for XCM execution on the dest chain, and1734 * it would be charged from the transferred assets. If set below1735 * requirements, the execution may fail and assets wouldn't be1736 * received.1737 * 1738 * `fee_item` is index of the currencies tuple that we want to use for1739 * payment1740 * 1741 * It's a no-op if any error on local XCM execution or message sending.1742 * Note sending assets out per se doesn't guarantee they would be1743 * received. Receiving depends on if the XCM message could be delivered1744 * by the network, and if the receiving chain would handle1745 * messages correctly.1746 **/1747 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]>;1748 /**1749 * Transfer native currencies specifying the fee and amount as1750 * separate.1751 * 1752 * `dest_weight` is the weight for XCM execution on the dest chain, and1753 * it would be charged from the transferred assets. If set below1754 * requirements, the execution may fail and assets wouldn't be1755 * received.1756 * 1757 * `fee` is the amount to be spent to pay for execution in destination1758 * chain. Both fee and amount will be subtracted form the callers1759 * balance.1760 * 1761 * If `fee` is not high enough to cover for the execution costs in the1762 * destination chain, then the assets will be trapped in the1763 * destination chain1764 * 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 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]>;1772 /**1773 * Generic tx1774 **/1775 [key: string]: SubmittableExtrinsicFunction<ApiType>;1776 };1777 } // AugmentedSubmittables1778} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts99.0 KiBsourcehistory