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, EthereumLog, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1314export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;15export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;16export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1718declare module '@polkadot/api-base/types/submittable' {19 interface AugmentedSubmittables<ApiType extends ApiTypes> {20 appPromotion: {21 /**22 * Recalculates interest for the specified number of stakers.23 * If all stakers are not recalculated, the next call of the extrinsic24 * will continue the recalculation, from those stakers for whom this25 * was not perform in last call.26 * 27 * # Permissions28 * 29 * * Pallet admin30 * 31 * # Arguments32 * 33 * * `stakers_number`: the number of stakers for which recalculation will be performed34 **/35 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;36 /**37 * Sets an address as the the admin.38 * 39 * # Permissions40 * 41 * * Sudo42 * 43 * # Arguments44 * 45 * * `admin`: account of the new admin.46 **/47 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;48 /**49 * Sets the pallet to be the sponsor for the collection.50 * 51 * # Permissions52 * 53 * * Pallet admin54 * 55 * # Arguments56 * 57 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`58 **/59 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;60 /**61 * Sets the pallet to be the sponsor for the contract.62 * 63 * # Permissions64 * 65 * * Pallet admin66 * 67 * # Arguments68 * 69 * * `contract_id`: the contract address that will be sponsored by `pallet_id`70 **/71 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;72 /**73 * Stakes the amount of native tokens.74 * Sets `amount` to the locked state.75 * The maximum number of stakes for a staker is 10.76 * 77 * # Arguments78 * 79 * * `amount`: in native tokens.80 **/81 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;82 /**83 * Removes the pallet as the sponsor for the collection.84 * Returns [`NoPermission`][`Error::NoPermission`]85 * if the pallet wasn't the sponsor.86 * 87 * # Permissions88 * 89 * * Pallet admin90 * 91 * # Arguments92 * 93 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`94 **/95 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;96 /**97 * Removes the pallet as the sponsor for the contract.98 * Returns [`NoPermission`][`Error::NoPermission`]99 * if the pallet wasn't the sponsor.100 * 101 * # Permissions102 * 103 * * Pallet admin104 * 105 * # Arguments106 * 107 * * `contract_id`: the contract address that is sponsored by `pallet_id`108 **/109 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;110 /**111 * Unstakes all stakes.112 * Moves the sum of all stakes to the `reserved` state.113 * After the end of `PendingInterval` this sum becomes completely114 * free for further use.115 **/116 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;117 /**118 * Generic tx119 **/120 [key: string]: SubmittableExtrinsicFunction<ApiType>;121 };122 balances: {123 /**124 * Exactly as `transfer`, except the origin must be root and the source account may be125 * specified.126 * # <weight>127 * - Same as transfer, but additional read and write because the source account is not128 * assumed to be in the overlay.129 * # </weight>130 **/131 forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Compact<u128>]>;132 /**133 * Unreserve some balance from a user by force.134 * 135 * Can only be called by ROOT.136 **/137 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;138 /**139 * Set the balances of a given account.140 * 141 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will142 * also alter the total issuance of the system (`TotalIssuance`) appropriately.143 * If the new free or reserved balance is below the existential deposit,144 * it will reset the account nonce (`frame_system::AccountNonce`).145 * 146 * The dispatch origin for this call is `root`.147 **/148 setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;149 /**150 * Transfer some liquid free balance to another account.151 * 152 * `transfer` will set the `FreeBalance` of the sender and receiver.153 * If the sender's account is below the existential deposit as a result154 * of the transfer, the account will be reaped.155 * 156 * The dispatch origin for this call must be `Signed` by the transactor.157 * 158 * # <weight>159 * - Dependent on arguments but not critical, given proper implementations for input config160 * types. See related functions below.161 * - It contains a limited number of reads and writes internally and no complex162 * computation.163 * 164 * Related functions:165 * 166 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.167 * - Transferring balances to accounts that did not exist before will cause168 * `T::OnNewAccount::on_new_account` to be called.169 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.170 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check171 * that the transfer will not kill the origin account.172 * ---------------------------------173 * - Origin account is already in memory, so no DB operations for them.174 * # </weight>175 **/176 transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;177 /**178 * Transfer the entire transferable balance from the caller account.179 * 180 * NOTE: This function only attempts to transfer _transferable_ balances. This means that181 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be182 * transferred by this function. To ensure that this function results in a killed account,183 * you might need to prepare the account by removing any reference counters, storage184 * deposits, etc...185 * 186 * The dispatch origin of this call must be Signed.187 * 188 * - `dest`: The recipient of the transfer.189 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all190 * of the funds the account has, causing the sender account to be killed (false), or191 * transfer everything except at least the existential deposit, which will guarantee to192 * keep the sender account alive (true). # <weight>193 * - O(1). Just like transfer, but reading the user's transferable balance first.194 * #</weight>195 **/196 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;197 /**198 * Same as the [`transfer`] call, but with a check that the transfer will not kill the199 * origin account.200 * 201 * 99% of the time you want [`transfer`] instead.202 * 203 * [`transfer`]: struct.Pallet.html#method.transfer204 **/205 transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;206 /**207 * Generic tx208 **/209 [key: string]: SubmittableExtrinsicFunction<ApiType>;210 };211 charging: {212 /**213 * Generic tx214 **/215 [key: string]: SubmittableExtrinsicFunction<ApiType>;216 };217 configuration: {218 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;219 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;220 setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;221 /**222 * Generic tx223 **/224 [key: string]: SubmittableExtrinsicFunction<ApiType>;225 };226 cumulusXcm: {227 /**228 * Generic tx229 **/230 [key: string]: SubmittableExtrinsicFunction<ApiType>;231 };232 dmpQueue: {233 /**234 * Service a single overweight message.235 * 236 * - `origin`: Must pass `ExecuteOverweightOrigin`.237 * - `index`: The index of the overweight message to service.238 * - `weight_limit`: The amount of weight that message execution may take.239 * 240 * Errors:241 * - `Unknown`: Message of `index` is unknown.242 * - `OverLimit`: Message execution may use greater than `weight_limit`.243 * 244 * Events:245 * - `OverweightServiced`: On success.246 **/247 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;248 /**249 * Generic tx250 **/251 [key: string]: SubmittableExtrinsicFunction<ApiType>;252 };253 ethereum: {254 /**255 * Transact an Ethereum transaction.256 **/257 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;258 /**259 * Generic tx260 **/261 [key: string]: SubmittableExtrinsicFunction<ApiType>;262 };263 evm: {264 /**265 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.266 **/267 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>]>>]>;268 /**269 * Issue an EVM create operation. This is similar to a contract creation transaction in270 * Ethereum.271 **/272 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>]>>]>;273 /**274 * Issue an EVM create2 operation.275 **/276 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>]>>]>;277 /**278 * Withdraw balance from EVM into currency/balances pallet.279 **/280 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;281 /**282 * Generic tx283 **/284 [key: string]: SubmittableExtrinsicFunction<ApiType>;285 };286 evmMigration: {287 /**288 * Start contract migration, inserts contract stub at target address,289 * and marks account as pending, allowing to insert storage290 **/291 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;292 /**293 * Finish contract migration, allows it to be called.294 * It is not possible to alter contract storage via [`Self::set_data`]295 * after this call.296 **/297 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;298 /**299 * Create ethereum events attached to the fake transaction300 **/301 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;302 /**303 * Create substrate events304 **/305 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;306 /**307 * Insert items into contract storage, this method can be called308 * multiple times309 **/310 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;311 /**312 * Generic tx313 **/314 [key: string]: SubmittableExtrinsicFunction<ApiType>;315 };316 foreignAssets: {317 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]>;318 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]>;319 /**320 * Generic tx321 **/322 [key: string]: SubmittableExtrinsicFunction<ApiType>;323 };324 inflation: {325 /**326 * This method sets the inflation start date. Can be only called once.327 * Inflation start block can be backdated and will catch up. The method will create Treasury328 * account if it does not exist and perform the first inflation deposit.329 * 330 * # Permissions331 * 332 * * Root333 * 334 * # Arguments335 * 336 * * inflation_start_relay_block: The relay chain block at which inflation should start337 **/338 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;339 /**340 * Generic tx341 **/342 [key: string]: SubmittableExtrinsicFunction<ApiType>;343 };344 maintenance: {345 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;346 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;347 /**348 * Generic tx349 **/350 [key: string]: SubmittableExtrinsicFunction<ApiType>;351 };352 parachainSystem: {353 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;354 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;355 /**356 * Set the current validation data.357 * 358 * This should be invoked exactly once per block. It will panic at the finalization359 * phase if the call was not invoked.360 * 361 * The dispatch origin for this call must be `Inherent`362 * 363 * As a side effect, this function upgrades the current validation function364 * if the appropriate time has come.365 **/366 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;367 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;368 /**369 * Generic tx370 **/371 [key: string]: SubmittableExtrinsicFunction<ApiType>;372 };373 polkadotXcm: {374 /**375 * Execute an XCM message from a local, signed, origin.376 * 377 * An event is deposited indicating whether `msg` could be executed completely or only378 * partially.379 * 380 * No more than `max_weight` will be used in its attempted execution. If this is less than the381 * maximum amount of weight that the message could take to be executed, then no execution382 * attempt will be made.383 * 384 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully385 * to completion; only that *some* of it was executed.386 **/387 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;388 /**389 * Set a safe XCM version (the version that XCM should be encoded with if the most recent390 * version a destination can accept is unknown).391 * 392 * - `origin`: Must be Root.393 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.394 **/395 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;396 /**397 * Ask a location to notify us regarding their XCM version and any changes to it.398 * 399 * - `origin`: Must be Root.400 * - `location`: The location to which we should subscribe for XCM version notifications.401 **/402 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;403 /**404 * Require that a particular destination should no longer notify us regarding any XCM405 * version changes.406 * 407 * - `origin`: Must be Root.408 * - `location`: The location to which we are currently subscribed for XCM version409 * notifications which we no longer desire.410 **/411 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;412 /**413 * Extoll that a particular destination can be communicated with through a particular414 * version of XCM.415 * 416 * - `origin`: Must be Root.417 * - `location`: The destination that is being described.418 * - `xcm_version`: The latest version of XCM that `location` supports.419 **/420 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;421 /**422 * Transfer some assets from the local chain to the sovereign account of a destination423 * chain and forward a notification XCM.424 * 425 * Fee payment on the destination side is made from the asset in the `assets` vector of426 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight427 * is needed than `weight_limit`, then the operation will fail and the assets send may be428 * at risk.429 * 430 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.431 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send432 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.433 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be434 * an `AccountId32` value.435 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the436 * `dest` side.437 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay438 * fees.439 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.440 **/441 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]>;442 /**443 * Teleport some assets from the local chain to some destination chain.444 * 445 * Fee payment on the destination side is made from the asset in the `assets` vector of446 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight447 * is needed than `weight_limit`, then the operation will fail and the assets send may be448 * at risk.449 * 450 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.451 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send452 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.453 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be454 * an `AccountId32` value.455 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the456 * `dest` side. May not be empty.457 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay458 * fees.459 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.460 **/461 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]>;462 /**463 * Transfer some assets from the local chain to the sovereign account of a destination464 * chain and forward a notification XCM.465 * 466 * Fee payment on the destination side is made from the asset in the `assets` vector of467 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,468 * with all fees taken as needed from the asset.469 * 470 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.471 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send472 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.473 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be474 * an `AccountId32` value.475 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the476 * `dest` side.477 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay478 * fees.479 **/480 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]>;481 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;482 /**483 * Teleport some assets from the local chain to some destination chain.484 * 485 * Fee payment on the destination side is made from the asset in the `assets` vector of486 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,487 * with all fees taken as needed from the asset.488 * 489 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.490 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send491 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.492 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be493 * an `AccountId32` value.494 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the495 * `dest` side. May not be empty.496 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay497 * fees.498 **/499 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]>;500 /**501 * Generic tx502 **/503 [key: string]: SubmittableExtrinsicFunction<ApiType>;504 };505 rmrkCore: {506 /**507 * Accept an NFT sent from another account to self or an owned NFT.508 * 509 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.510 * 511 * # Permissions:512 * - Token-owner-to-be513 * 514 * # Arguments:515 * - `origin`: sender of the transaction516 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.517 * - `rmrk_nft_id`: ID of the NFT to be accepted.518 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,519 * whichever the accepted NFT was sent to.520 **/521 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;522 /**523 * Accept the addition of a newly created pending resource to an existing NFT.524 * 525 * This transaction is needed when a resource is created and assigned to an NFT526 * by a non-owner, i.e. the collection issuer, with one of the527 * [`add_...` transactions](Pallet::add_basic_resource).528 * 529 * # Permissions:530 * - Token owner531 * 532 * # Arguments:533 * - `origin`: sender of the transaction534 * - `rmrk_collection_id`: RMRK collection ID of the NFT.535 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.536 * - `resource_id`: ID of the newly created pending resource.537 * accept the addition of a new resource to an existing NFT538 **/539 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;540 /**541 * Accept the removal of a removal-pending resource from an NFT.542 * 543 * This transaction is needed when a non-owner, i.e. the collection issuer,544 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.545 * 546 * # Permissions:547 * - Token owner548 * 549 * # Arguments:550 * - `origin`: sender of the transaction551 * - `rmrk_collection_id`: RMRK collection ID of the NFT.552 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.553 * - `resource_id`: ID of the removal-pending resource.554 **/555 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;556 /**557 * Create and set/propose a basic resource for an NFT.558 * 559 * A basic resource is the simplest, lacking a Base and anything that comes with it.560 * See RMRK docs for more information and examples.561 * 562 * # Permissions:563 * - Collection issuer - if not the token owner, adding the resource will warrant564 * the owner's [acceptance](Pallet::accept_resource).565 * 566 * # Arguments:567 * - `origin`: sender of the transaction568 * - `rmrk_collection_id`: RMRK collection ID of the NFT.569 * - `nft_id`: ID of the NFT to assign a resource to.570 * - `resource`: Data of the resource to be created.571 **/572 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]>;573 /**574 * Create and set/propose a composable resource for an NFT.575 * 576 * A composable resource links to a Base and has a subset of its Parts it is composed of.577 * See RMRK docs for more information and examples.578 * 579 * # Permissions:580 * - Collection issuer - if not the token owner, adding the resource will warrant581 * the owner's [acceptance](Pallet::accept_resource).582 * 583 * # Arguments:584 * - `origin`: sender of the transaction585 * - `rmrk_collection_id`: RMRK collection ID of the NFT.586 * - `nft_id`: ID of the NFT to assign a resource to.587 * - `resource`: Data of the resource to be created.588 **/589 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]>;590 /**591 * Create and set/propose a slot resource for an NFT.592 * 593 * A slot resource links to a Base and a slot ID in it which it can fit into.594 * See RMRK docs for more information and examples.595 * 596 * # Permissions:597 * - Collection issuer - if not the token owner, adding the resource will warrant598 * the owner's [acceptance](Pallet::accept_resource).599 * 600 * # Arguments:601 * - `origin`: sender of the transaction602 * - `rmrk_collection_id`: RMRK collection ID of the NFT.603 * - `nft_id`: ID of the NFT to assign a resource to.604 * - `resource`: Data of the resource to be created.605 **/606 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]>;607 /**608 * Burn an NFT, destroying it and its nested tokens up to the specified limit.609 * If the burning budget is exceeded, the transaction is reverted.610 * 611 * This is the way to burn a nested token as well.612 * 613 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).614 * 615 * # Permissions:616 * * Token owner617 * 618 * # Arguments:619 * - `origin`: sender of the transaction620 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.621 * - `nft_id`: ID of the NFT to be destroyed.622 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction623 * is reverted if there are more tokens to burn in the nesting tree than this number.624 * This is primarily a mechanism of transaction weight control.625 **/626 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;627 /**628 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).629 * 630 * # Permissions:631 * * Collection issuer632 * 633 * # Arguments:634 * - `origin`: sender of the transaction635 * - `collection_id`: RMRK collection ID to change the issuer of.636 * - `new_issuer`: Collection's new issuer.637 **/638 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;639 /**640 * Create a new collection of NFTs.641 * 642 * # Permissions:643 * * Anyone - will be assigned as the issuer of the collection.644 * 645 * # Arguments:646 * - `origin`: sender of the transaction647 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.648 * - `max`: Optional maximum number of tokens.649 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.650 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.651 **/652 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;653 /**654 * Destroy a collection.655 * 656 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.657 * 658 * # Permissions:659 * * Collection issuer660 * 661 * # Arguments:662 * - `origin`: sender of the transaction663 * - `collection_id`: RMRK ID of the collection to destroy.664 **/665 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;666 /**667 * "Lock" the collection and prevent new token creation. Cannot be undone.668 * 669 * # Permissions:670 * * Collection issuer671 * 672 * # Arguments:673 * - `origin`: sender of the transaction674 * - `collection_id`: RMRK ID of the collection to lock.675 **/676 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;677 /**678 * Mint an NFT in a specified collection.679 * 680 * # Permissions:681 * * Collection issuer682 * 683 * # Arguments:684 * - `origin`: sender of the transaction685 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).686 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.687 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.688 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.689 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.690 * - `transferable`: Can this NFT be transferred? Cannot be changed.691 * - `resources`: Resource data to be added to the NFT immediately after minting.692 **/693 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>>]>;694 /**695 * Reject an NFT sent from another account to self or owned NFT.696 * The NFT in question will not be sent back and burnt instead.697 * 698 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.699 * 700 * # Permissions:701 * - Token-owner-to-be-not702 * 703 * # Arguments:704 * - `origin`: sender of the transaction705 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.706 * - `rmrk_nft_id`: ID of the NFT to be rejected.707 **/708 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;709 /**710 * Remove and erase a resource from an NFT.711 * 712 * If the sender does not own the NFT, then it will be pending confirmation,713 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.714 * 715 * # Permissions716 * - Collection issuer717 * 718 * # Arguments719 * - `origin`: sender of the transaction720 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.721 * - `nft_id`: ID of the NFT with a resource to be removed.722 * - `resource_id`: ID of the resource to be removed.723 **/724 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;725 /**726 * Transfer an NFT from an account/NFT A to another account/NFT B.727 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].728 * 729 * If the target owner is an NFT owned by another account, then the NFT will enter730 * the pending state and will have to be accepted by the other account.731 * 732 * # Permissions:733 * - Token owner734 * 735 * # Arguments:736 * - `origin`: sender of the transaction737 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.738 * - `rmrk_nft_id`: ID of the NFT to be transferred.739 * - `new_owner`: New owner of the nft which can be either an account or a NFT.740 **/741 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;742 /**743 * Set a different order of resource priorities for an NFT. Priorities can be used,744 * for example, for order of rendering.745 * 746 * Note that the priorities are not updated automatically, and are an empty vector747 * by default. There is no pre-set definition for the order to be particular,748 * it can be interpreted arbitrarily use-case by use-case.749 * 750 * # Permissions:751 * - Token owner752 * 753 * # Arguments:754 * - `origin`: sender of the transaction755 * - `rmrk_collection_id`: RMRK collection ID of the NFT.756 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.757 * - `priorities`: Ordered vector of resource IDs.758 **/759 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;760 /**761 * Add or edit a custom user property, a key-value pair, describing the metadata762 * of a token or a collection, on either one of these.763 * 764 * Note that in this proxy implementation many details regarding RMRK are stored765 * as scoped properties prefixed with "rmrk:", normally inaccessible766 * to external transactions and RPCs.767 * 768 * # Permissions:769 * - Collection issuer - in case of collection property770 * - Token owner - in case of NFT property771 * 772 * # Arguments:773 * - `origin`: sender of the transaction774 * - `rmrk_collection_id`: RMRK collection ID.775 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.776 * - `key`: Key of the custom property to be referenced by.777 * - `value`: Value of the custom property to be stored.778 **/779 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]>;780 /**781 * Generic tx782 **/783 [key: string]: SubmittableExtrinsicFunction<ApiType>;784 };785 rmrkEquip: {786 /**787 * Create a new Base.788 * 789 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)790 * 791 * # Permissions792 * - Anyone - will be assigned as the issuer of the Base.793 * 794 * # Arguments:795 * - `origin`: Caller, will be assigned as the issuer of the Base796 * - `base_type`: Arbitrary media type, e.g. "svg".797 * - `symbol`: Arbitrary client-chosen symbol.798 * - `parts`: Array of Fixed and Slot Parts composing the Base,799 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).800 **/801 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>]>;802 /**803 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.804 * 805 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).806 * 807 * # Permissions:808 * - Base issuer809 * 810 * # Arguments:811 * - `origin`: sender of the transaction812 * - `base_id`: Base containing the Slot Part to be updated.813 * - `slot_id`: Slot Part whose Equippable List is being updated .814 * - `equippables`: List of equippables that will override the current Equippables list.815 **/816 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]>;817 /**818 * Add a Theme to a Base.819 * A Theme named "default" is required prior to adding other Themes.820 * 821 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).822 * 823 * # Permissions:824 * - Base issuer825 * 826 * # Arguments:827 * - `origin`: sender of the transaction828 * - `base_id`: Base ID containing the Theme to be updated.829 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an830 * array of [key, value, inherit].831 * - `key`: Arbitrary BoundedString, defined by client.832 * - `value`: Arbitrary BoundedString, defined by client.833 * - `inherit`: Optional bool.834 **/835 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;836 /**837 * Generic tx838 **/839 [key: string]: SubmittableExtrinsicFunction<ApiType>;840 };841 scheduler: {842 /**843 * Cancel an anonymously scheduled task.844 * 845 * The `T::OriginPrivilegeCmp` decides whether the given origin is allowed to cancel the task or not.846 **/847 cancel: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;848 /**849 * Cancel a named scheduled task.850 * 851 * The `T::OriginPrivilegeCmp` decides whether the given origin is allowed to cancel the task or not.852 **/853 cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;854 /**855 * Change a named task's priority.856 * 857 * Only the `T::PrioritySetOrigin` is allowed to change the task's priority.858 **/859 changeNamedPriority: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u8]>;860 /**861 * Anonymously schedule a task.862 * 863 * Only `T::ScheduleOrigin` is allowed to schedule a task.864 * Only `T::PrioritySetOrigin` is allowed to set the task's priority.865 **/866 schedule: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: Option<u8> | null | Uint8Array | u8 | AnyNumber, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, Option<u8>, Call]>;867 /**868 * Anonymously schedule a task after a delay.869 * 870 * # <weight>871 * Same as [`schedule`].872 * # </weight>873 **/874 scheduleAfter: AugmentedSubmittable<(after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: Option<u8> | null | Uint8Array | u8 | AnyNumber, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, Option<u8>, Call]>;875 /**876 * Schedule a named task.877 * 878 * Only `T::ScheduleOrigin` is allowed to schedule a task.879 * Only `T::PrioritySetOrigin` is allowed to set the task's priority.880 **/881 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: Option<u8> | null | Uint8Array | u8 | AnyNumber, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, Option<u8>, Call]>;882 /**883 * Schedule a named task after a delay.884 * 885 * Only `T::ScheduleOrigin` is allowed to schedule a task.886 * Only `T::PrioritySetOrigin` is allowed to set the task's priority.887 * 888 * # <weight>889 * Same as [`schedule_named`](Self::schedule_named).890 * # </weight>891 **/892 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: Option<u8> | null | Uint8Array | u8 | AnyNumber, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, Option<u8>, Call]>;893 /**894 * Generic tx895 **/896 [key: string]: SubmittableExtrinsicFunction<ApiType>;897 };898 structure: {899 /**900 * Generic tx901 **/902 [key: string]: SubmittableExtrinsicFunction<ApiType>;903 };904 sudo: {905 /**906 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo907 * key.908 * 909 * The dispatch origin for this call must be _Signed_.910 * 911 * # <weight>912 * - O(1).913 * - Limited storage reads.914 * - One DB change.915 * # </weight>916 **/917 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;918 /**919 * Authenticates the sudo key and dispatches a function call with `Root` origin.920 * 921 * The dispatch origin for this call must be _Signed_.922 * 923 * # <weight>924 * - O(1).925 * - Limited storage reads.926 * - One DB write (event).927 * - Weight of derivative `call` execution + 10,000.928 * # </weight>929 **/930 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;931 /**932 * Authenticates the sudo key and dispatches a function call with `Signed` origin from933 * a given account.934 * 935 * The dispatch origin for this call must be _Signed_.936 * 937 * # <weight>938 * - O(1).939 * - Limited storage reads.940 * - One DB write (event).941 * - Weight of derivative `call` execution + 10,000.942 * # </weight>943 **/944 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]>;945 /**946 * Authenticates the sudo key and dispatches a function call with `Root` origin.947 * This function does not check the weight of the call, and instead allows the948 * Sudo user to specify the weight of the call.949 * 950 * The dispatch origin for this call must be _Signed_.951 * 952 * # <weight>953 * - O(1).954 * - The weight of this call is defined by the caller.955 * # </weight>956 **/957 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;958 /**959 * Generic tx960 **/961 [key: string]: SubmittableExtrinsicFunction<ApiType>;962 };963 system: {964 /**965 * A dispatch that will fill the block weight up to the given ratio.966 **/967 fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;968 /**969 * Kill all storage items with a key that starts with the given prefix.970 * 971 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under972 * the prefix we are removing to accurately calculate the weight of this function.973 **/974 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;975 /**976 * Kill some items from storage.977 **/978 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;979 /**980 * Make some on-chain remark.981 * 982 * # <weight>983 * - `O(1)`984 * # </weight>985 **/986 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;987 /**988 * Make some on-chain remark and emit event.989 **/990 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;991 /**992 * Set the new runtime code.993 * 994 * # <weight>995 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`996 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is997 * expensive).998 * - 1 storage write (codec `O(C)`).999 * - 1 digest item.1000 * - 1 event.1001 * The weight of this function is dependent on the runtime, but generally this is very1002 * expensive. We will treat this as a full block.1003 * # </weight>1004 **/1005 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1006 /**1007 * Set the new runtime code without doing any checks of the given `code`.1008 * 1009 * # <weight>1010 * - `O(C)` where `C` length of `code`1011 * - 1 storage write (codec `O(C)`).1012 * - 1 digest item.1013 * - 1 event.1014 * The weight of this function is dependent on the runtime. We will treat this as a full1015 * block. # </weight>1016 **/1017 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1018 /**1019 * Set the number of pages in the WebAssembly environment's heap.1020 **/1021 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1022 /**1023 * Set some items of storage.1024 **/1025 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1026 /**1027 * Generic tx1028 **/1029 [key: string]: SubmittableExtrinsicFunction<ApiType>;1030 };1031 testUtils: {1032 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1033 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1034 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1035 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1036 selfCancelingInc: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, maxTestValue: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32]>;1037 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1038 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1039 /**1040 * Generic tx1041 **/1042 [key: string]: SubmittableExtrinsicFunction<ApiType>;1043 };1044 timestamp: {1045 /**1046 * Set the current time.1047 * 1048 * This call should be invoked exactly once per block. It will panic at the finalization1049 * phase, if this call hasn't been invoked by that time.1050 * 1051 * The timestamp should be greater than the previous one by the amount specified by1052 * `MinimumPeriod`.1053 * 1054 * The dispatch origin for this call must be `Inherent`.1055 * 1056 * # <weight>1057 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1058 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1059 * `on_finalize`)1060 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1061 * # </weight>1062 **/1063 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1064 /**1065 * Generic tx1066 **/1067 [key: string]: SubmittableExtrinsicFunction<ApiType>;1068 };1069 tokens: {1070 /**1071 * Exactly as `transfer`, except the origin must be root and the source1072 * account may be specified.1073 * 1074 * The dispatch origin for this call must be _Root_.1075 * 1076 * - `source`: The sender of the transfer.1077 * - `dest`: The recipient of the transfer.1078 * - `currency_id`: currency type.1079 * - `amount`: free balance amount to tranfer.1080 **/1081 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>]>;1082 /**1083 * Set the balances of a given account.1084 * 1085 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1086 * will also decrease the total issuance of the system1087 * (`TotalIssuance`). If the new free or reserved balance is below the1088 * existential deposit, it will reap the `AccountInfo`.1089 * 1090 * The dispatch origin for this call is `root`.1091 **/1092 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>]>;1093 /**1094 * Transfer some liquid free balance to another account.1095 * 1096 * `transfer` will set the `FreeBalance` of the sender and receiver.1097 * It will decrease the total issuance of the system by the1098 * `TransferFee`. If the sender's account is below the existential1099 * deposit as a result of the transfer, the account will be reaped.1100 * 1101 * The dispatch origin for this call must be `Signed` by the1102 * transactor.1103 * 1104 * - `dest`: The recipient of the transfer.1105 * - `currency_id`: currency type.1106 * - `amount`: free balance amount to tranfer.1107 **/1108 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>]>;1109 /**1110 * Transfer all remaining balance to the given account.1111 * 1112 * NOTE: This function only attempts to transfer _transferable_1113 * balances. This means that any locked, reserved, or existential1114 * deposits (when `keep_alive` is `true`), will not be transferred by1115 * this function. To ensure that this function results in a killed1116 * account, you might need to prepare the account by removing any1117 * reference counters, storage deposits, etc...1118 * 1119 * The dispatch origin for this call must be `Signed` by the1120 * transactor.1121 * 1122 * - `dest`: The recipient of the transfer.1123 * - `currency_id`: currency type.1124 * - `keep_alive`: A boolean to determine if the `transfer_all`1125 * operation should send all of the funds the account has, causing1126 * the sender account to be killed (false), or transfer everything1127 * except at least the existential deposit, which will guarantee to1128 * keep the sender account alive (true).1129 **/1130 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]>;1131 /**1132 * Same as the [`transfer`] call, but with a check that the transfer1133 * will not kill the origin account.1134 * 1135 * 99% of the time you want [`transfer`] instead.1136 * 1137 * The dispatch origin for this call must be `Signed` by the1138 * transactor.1139 * 1140 * - `dest`: The recipient of the transfer.1141 * - `currency_id`: currency type.1142 * - `amount`: free balance amount to tranfer.1143 **/1144 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>]>;1145 /**1146 * Generic tx1147 **/1148 [key: string]: SubmittableExtrinsicFunction<ApiType>;1149 };1150 treasury: {1151 /**1152 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1153 * and the original deposit will be returned.1154 * 1155 * May only be called from `T::ApproveOrigin`.1156 * 1157 * # <weight>1158 * - Complexity: O(1).1159 * - DbReads: `Proposals`, `Approvals`1160 * - DbWrite: `Approvals`1161 * # </weight>1162 **/1163 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1164 /**1165 * Put forward a suggestion for spending. A deposit proportional to the value1166 * is reserved and slashed if the proposal is rejected. It is returned once the1167 * proposal is awarded.1168 * 1169 * # <weight>1170 * - Complexity: O(1)1171 * - DbReads: `ProposalCount`, `origin account`1172 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1173 * # </weight>1174 **/1175 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]>;1176 /**1177 * Reject a proposed spend. The original deposit will be slashed.1178 * 1179 * May only be called from `T::RejectOrigin`.1180 * 1181 * # <weight>1182 * - Complexity: O(1)1183 * - DbReads: `Proposals`, `rejected proposer account`1184 * - DbWrites: `Proposals`, `rejected proposer account`1185 * # </weight>1186 **/1187 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1188 /**1189 * Force a previously approved proposal to be removed from the approval queue.1190 * The original deposit will no longer be returned.1191 * 1192 * May only be called from `T::RejectOrigin`.1193 * - `proposal_id`: The index of a proposal1194 * 1195 * # <weight>1196 * - Complexity: O(A) where `A` is the number of approvals1197 * - Db reads and writes: `Approvals`1198 * # </weight>1199 * 1200 * Errors:1201 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1202 * i.e., the proposal has not been approved. This could also mean the proposal does not1203 * exist altogether, thus there is no way it would have been approved in the first place.1204 **/1205 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1206 /**1207 * Propose and approve a spend of treasury funds.1208 * 1209 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1210 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1211 * - `beneficiary`: The destination account for the transfer.1212 * 1213 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1214 * beneficiary.1215 **/1216 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]>;1217 /**1218 * Generic tx1219 **/1220 [key: string]: SubmittableExtrinsicFunction<ApiType>;1221 };1222 unique: {1223 /**1224 * Add an admin to a collection.1225 * 1226 * NFT Collection can be controlled by multiple admin addresses1227 * (some which can also be servers, for example). Admins can issue1228 * and burn NFTs, as well as add and remove other admins,1229 * but cannot change NFT or Collection ownership.1230 * 1231 * # Permissions1232 * 1233 * * Collection owner1234 * * Collection admin1235 * 1236 * # Arguments1237 * 1238 * * `collection_id`: ID of the Collection to add an admin for.1239 * * `new_admin`: Address of new admin to add.1240 **/1241 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1242 /**1243 * Add an address to allow list.1244 * 1245 * # Permissions1246 * 1247 * * Collection owner1248 * * Collection admin1249 * 1250 * # Arguments1251 * 1252 * * `collection_id`: ID of the modified collection.1253 * * `address`: ID of the address to be added to the allowlist.1254 **/1255 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1256 /**1257 * Allow a non-permissioned address to transfer or burn an item.1258 * 1259 * # Permissions1260 * 1261 * * Collection owner1262 * * Collection admin1263 * * Current item owner1264 * 1265 * # Arguments1266 * 1267 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1268 * * `collection_id`: ID of the collection the item belongs to.1269 * * `item_id`: ID of the item transactions on which are now approved.1270 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1271 * Set to 0 to revoke the approval.1272 **/1273 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]>;1274 /**1275 * Destroy a token on behalf of the owner as a non-owner account.1276 * 1277 * See also: [`approve`][`Pallet::approve`].1278 * 1279 * After this method executes, one approval is removed from the total so that1280 * the approved address will not be able to transfer this item again from this owner.1281 * 1282 * # Permissions1283 * 1284 * * Collection owner1285 * * Collection admin1286 * * Current token owner1287 * * Address approved by current item owner1288 * 1289 * # Arguments1290 * 1291 * * `from`: The owner of the burning item.1292 * * `collection_id`: ID of the collection to which the item belongs.1293 * * `item_id`: ID of item to burn.1294 * * `value`: Number of pieces to burn.1295 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1296 * * Fungible Mode: The desired number of pieces to burn.1297 * * Re-Fungible Mode: The desired number of pieces to burn.1298 **/1299 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]>;1300 /**1301 * Destroy an item.1302 * 1303 * # Permissions1304 * 1305 * * Collection owner1306 * * Collection admin1307 * * Current item owner1308 * 1309 * # Arguments1310 * 1311 * * `collection_id`: ID of the collection to which the item belongs.1312 * * `item_id`: ID of item to burn.1313 * * `value`: Number of pieces of the item to destroy.1314 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1315 * * Fungible Mode: The desired number of pieces to burn.1316 * * Re-Fungible Mode: The desired number of pieces to burn.1317 **/1318 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1319 /**1320 * Change the owner of the collection.1321 * 1322 * # Permissions1323 * 1324 * * Collection owner1325 * 1326 * # Arguments1327 * 1328 * * `collection_id`: ID of the modified collection.1329 * * `new_owner`: ID of the account that will become the owner.1330 **/1331 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1332 /**1333 * Confirm own sponsorship of a collection, becoming the sponsor.1334 * 1335 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1336 * Sponsor can pay the fees of a transaction instead of the sender,1337 * but only within specified limits.1338 * 1339 * # Permissions1340 * 1341 * * Sponsor-to-be1342 * 1343 * # Arguments1344 * 1345 * * `collection_id`: ID of the collection with the pending sponsor.1346 **/1347 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1348 /**1349 * Create a collection of tokens.1350 * 1351 * Each Token may have multiple properties encoded as an array of bytes1352 * of certain length. The initial owner of the collection is set1353 * to the address that signed the transaction and can be changed later.1354 * 1355 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1356 * 1357 * # Permissions1358 * 1359 * * Anyone - becomes the owner of the new collection.1360 * 1361 * # Arguments1362 * 1363 * * `collection_name`: Wide-character string with collection name1364 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1365 * * `collection_description`: Wide-character string with collection description1366 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1367 * * `token_prefix`: Byte string containing the token prefix to mark a collection1368 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1369 * * `mode`: Type of items stored in the collection and type dependent data.1370 **/1371 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]>;1372 /**1373 * Create a collection with explicit parameters.1374 * 1375 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1376 * 1377 * # Permissions1378 * 1379 * * Anyone - becomes the owner of the new collection.1380 * 1381 * # Arguments1382 * 1383 * * `data`: Explicit data of a collection used for its creation.1384 **/1385 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]>;1386 /**1387 * Mint an item within a collection.1388 * 1389 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1390 * 1391 * # Permissions1392 * 1393 * * Collection owner1394 * * Collection admin1395 * * Anyone if1396 * * Allow List is enabled, and1397 * * Address is added to allow list, and1398 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1399 * 1400 * # Arguments1401 * 1402 * * `collection_id`: ID of the collection to which an item would belong.1403 * * `owner`: Address of the initial owner of the item.1404 * * `data`: Token data describing the item to store on chain.1405 **/1406 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]>;1407 /**1408 * Create multiple items within a collection.1409 * 1410 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1411 * 1412 * # Permissions1413 * 1414 * * Collection owner1415 * * Collection admin1416 * * Anyone if1417 * * Allow List is enabled, and1418 * * Address is added to the allow list, and1419 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1420 * 1421 * # Arguments1422 * 1423 * * `collection_id`: ID of the collection to which the tokens would belong.1424 * * `owner`: Address of the initial owner of the tokens.1425 * * `items_data`: Vector of data describing each item to be created.1426 **/1427 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>]>;1428 /**1429 * Create multiple items within a collection with explicitly specified initial parameters.1430 * 1431 * # Permissions1432 * 1433 * * Collection owner1434 * * Collection admin1435 * * Anyone if1436 * * Allow List is enabled, and1437 * * Address is added to allow list, and1438 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1439 * 1440 * # Arguments1441 * 1442 * * `collection_id`: ID of the collection to which the tokens would belong.1443 * * `data`: Explicit item creation data.1444 **/1445 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1446 /**1447 * Delete specified collection properties.1448 * 1449 * # Permissions1450 * 1451 * * Collection Owner1452 * * Collection Admin1453 * 1454 * # Arguments1455 * 1456 * * `collection_id`: ID of the modified collection.1457 * * `property_keys`: Vector of keys of the properties to be deleted.1458 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1459 **/1460 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1461 /**1462 * Delete specified token properties. Currently properties only work with NFTs.1463 * 1464 * # Permissions1465 * 1466 * * Depends on collection's token property permissions and specified property mutability:1467 * * Collection owner1468 * * Collection admin1469 * * Token owner1470 * 1471 * # Arguments1472 * 1473 * * `collection_id`: ID of the collection to which the token belongs.1474 * * `token_id`: ID of the modified token.1475 * * `property_keys`: Vector of keys of the properties to be deleted.1476 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1477 **/1478 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1479 /**1480 * Destroy a collection if no tokens exist within.1481 * 1482 * # Permissions1483 * 1484 * * Collection owner1485 * 1486 * # Arguments1487 * 1488 * * `collection_id`: Collection to destroy.1489 **/1490 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1491 /**1492 * Remove admin of a collection.1493 * 1494 * An admin address can remove itself. List of admins may become empty,1495 * in which case only Collection Owner will be able to add an Admin.1496 * 1497 * # Permissions1498 * 1499 * * Collection owner1500 * * Collection admin1501 * 1502 * # Arguments1503 * 1504 * * `collection_id`: ID of the collection to remove the admin for.1505 * * `account_id`: Address of the admin to remove.1506 **/1507 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1508 /**1509 * Remove a collection's a sponsor, making everyone pay for their own transactions.1510 * 1511 * # Permissions1512 * 1513 * * Collection owner1514 * 1515 * # Arguments1516 * 1517 * * `collection_id`: ID of the collection with the sponsor to remove.1518 **/1519 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1520 /**1521 * Remove an address from allow list.1522 * 1523 * # Permissions1524 * 1525 * * Collection owner1526 * * Collection admin1527 * 1528 * # Arguments1529 * 1530 * * `collection_id`: ID of the modified collection.1531 * * `address`: ID of the address to be removed from the allowlist.1532 **/1533 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1534 /**1535 * Re-partition a refungible token, while owning all of its parts/pieces.1536 * 1537 * # Permissions1538 * 1539 * * Token owner (must own every part)1540 * 1541 * # Arguments1542 * 1543 * * `collection_id`: ID of the collection the RFT belongs to.1544 * * `token_id`: ID of the RFT.1545 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1546 **/1547 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1548 /**1549 * Sets or unsets the approval of a given operator.1550 * 1551 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1552 * 1553 * # Arguments1554 * 1555 * * `owner`: Token owner1556 * * `operator`: Operator1557 * * `approve`: Should operator status be granted or revoked?1558 **/1559 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1560 /**1561 * Set specific limits of a collection. Empty, or None fields mean chain default.1562 * 1563 * # Permissions1564 * 1565 * * Collection owner1566 * * Collection admin1567 * 1568 * # Arguments1569 * 1570 * * `collection_id`: ID of the modified collection.1571 * * `new_limit`: New limits of the collection. Fields that are not set (None)1572 * will not overwrite the old ones.1573 **/1574 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]>;1575 /**1576 * Set specific permissions of a collection. Empty, or None fields mean chain default.1577 * 1578 * # Permissions1579 * 1580 * * Collection owner1581 * * Collection admin1582 * 1583 * # Arguments1584 * 1585 * * `collection_id`: ID of the modified collection.1586 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1587 * will not overwrite the old ones.1588 **/1589 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1590 /**1591 * Add or change collection properties.1592 * 1593 * # Permissions1594 * 1595 * * Collection owner1596 * * Collection admin1597 * 1598 * # Arguments1599 * 1600 * * `collection_id`: ID of the modified collection.1601 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1602 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1603 **/1604 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1605 /**1606 * Set (invite) a new collection sponsor.1607 * 1608 * If successful, confirmation from the sponsor-to-be will be pending.1609 * 1610 * # Permissions1611 * 1612 * * Collection owner1613 * * Collection admin1614 * 1615 * # Arguments1616 * 1617 * * `collection_id`: ID of the modified collection.1618 * * `new_sponsor`: ID of the account of the sponsor-to-be.1619 **/1620 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1621 /**1622 * Add or change token properties according to collection's permissions.1623 * Currently properties only work with NFTs.1624 * 1625 * # Permissions1626 * 1627 * * Depends on collection's token property permissions and specified property mutability:1628 * * Collection owner1629 * * Collection admin1630 * * Token owner1631 * 1632 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1633 * 1634 * # Arguments1635 * 1636 * * `collection_id: ID of the collection to which the token belongs.1637 * * `token_id`: ID of the modified token.1638 * * `properties`: Vector of key-value pairs stored as the token's metadata.1639 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1640 **/1641 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>]>;1642 /**1643 * Add or change token property permissions of a collection.1644 * 1645 * Without a permission for a particular key, a property with that key1646 * cannot be created in a token.1647 * 1648 * # Permissions1649 * 1650 * * Collection owner1651 * * Collection admin1652 * 1653 * # Arguments1654 * 1655 * * `collection_id`: ID of the modified collection.1656 * * `property_permissions`: Vector of permissions for property keys.1657 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1658 **/1659 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1660 /**1661 * Completely allow or disallow transfers for a particular collection.1662 * 1663 * # Permissions1664 * 1665 * * Collection owner1666 * 1667 * # Arguments1668 * 1669 * * `collection_id`: ID of the collection.1670 * * `value`: New value of the flag, are transfers allowed?1671 **/1672 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1673 /**1674 * Change ownership of the token.1675 * 1676 * # Permissions1677 * 1678 * * Collection owner1679 * * Collection admin1680 * * Current token owner1681 * 1682 * # Arguments1683 * 1684 * * `recipient`: Address of token recipient.1685 * * `collection_id`: ID of the collection the item belongs to.1686 * * `item_id`: ID of the item.1687 * * Non-Fungible Mode: Required.1688 * * Fungible Mode: Ignored.1689 * * Re-Fungible Mode: Required.1690 * 1691 * * `value`: Amount to transfer.1692 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1693 * * Fungible Mode: The desired number of pieces to transfer.1694 * * Re-Fungible Mode: The desired number of pieces to transfer.1695 **/1696 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]>;1697 /**1698 * Change ownership of an item on behalf of the owner as a non-owner account.1699 * 1700 * See the [`approve`][`Pallet::approve`] method for additional information.1701 * 1702 * After this method executes, one approval is removed from the total so that1703 * the approved address will not be able to transfer this item again from this owner.1704 * 1705 * # Permissions1706 * 1707 * * Collection owner1708 * * Collection admin1709 * * Current item owner1710 * * Address approved by current item owner1711 * 1712 * # Arguments1713 * 1714 * * `from`: Address that currently owns the token.1715 * * `recipient`: Address of the new token-owner-to-be.1716 * * `collection_id`: ID of the collection the item.1717 * * `item_id`: ID of the item to be transferred.1718 * * `value`: Amount to transfer.1719 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1720 * * Fungible Mode: The desired number of pieces to transfer.1721 * * Re-Fungible Mode: The desired number of pieces to transfer.1722 **/1723 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]>;1724 /**1725 * Generic tx1726 **/1727 [key: string]: SubmittableExtrinsicFunction<ApiType>;1728 };1729 vesting: {1730 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1731 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1732 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>]>;1733 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]>;1734 /**1735 * Generic tx1736 **/1737 [key: string]: SubmittableExtrinsicFunction<ApiType>;1738 };1739 xcmpQueue: {1740 /**1741 * Resumes all XCM executions for the XCMP queue.1742 * 1743 * Note that this function doesn't change the status of the in/out bound channels.1744 * 1745 * - `origin`: Must pass `ControllerOrigin`.1746 **/1747 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1748 /**1749 * Services a single overweight XCM.1750 * 1751 * - `origin`: Must pass `ExecuteOverweightOrigin`.1752 * - `index`: The index of the overweight XCM to service1753 * - `weight_limit`: The amount of weight that XCM execution may take.1754 * 1755 * Errors:1756 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1757 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1758 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1759 * 1760 * Events:1761 * - `OverweightServiced`: On success.1762 **/1763 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1764 /**1765 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1766 * 1767 * - `origin`: Must pass `ControllerOrigin`.1768 **/1769 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1770 /**1771 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1772 * messages from the channel.1773 * 1774 * - `origin`: Must pass `Root`.1775 * - `new`: Desired value for `QueueConfigData.drop_threshold`1776 **/1777 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1778 /**1779 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1780 * message sending may recommence after it has been suspended.1781 * 1782 * - `origin`: Must pass `Root`.1783 * - `new`: Desired value for `QueueConfigData.resume_threshold`1784 **/1785 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1786 /**1787 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1788 * suspend their sending.1789 * 1790 * - `origin`: Must pass `Root`.1791 * - `new`: Desired value for `QueueConfigData.suspend_value`1792 **/1793 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1794 /**1795 * Overwrites the amount of remaining weight under which we stop processing messages.1796 * 1797 * - `origin`: Must pass `Root`.1798 * - `new`: Desired value for `QueueConfigData.threshold_weight`1799 **/1800 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1801 /**1802 * Overwrites the speed to which the available weight approaches the maximum weight.1803 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1804 * 1805 * - `origin`: Must pass `Root`.1806 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1807 **/1808 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1809 /**1810 * Overwrite the maximum amount of weight any individual message may consume.1811 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1812 * 1813 * - `origin`: Must pass `Root`.1814 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1815 **/1816 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1817 /**1818 * Generic tx1819 **/1820 [key: string]: SubmittableExtrinsicFunction<ApiType>;1821 };1822 xTokens: {1823 /**1824 * Transfer native currencies.1825 * 1826 * `dest_weight_limit` is the weight for XCM execution on the dest1827 * chain, and it would be charged from the transferred assets. If set1828 * below requirements, the execution may fail and assets wouldn't be1829 * received.1830 * 1831 * It's a no-op if any error on local XCM execution or message sending.1832 * Note sending assets out per se doesn't guarantee they would be1833 * received. Receiving depends on if the XCM message could be delivered1834 * by the network, and if the receiving chain would handle1835 * messages correctly.1836 **/1837 transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1838 /**1839 * Transfer `MultiAsset`.1840 * 1841 * `dest_weight_limit` is the weight for XCM execution on the dest1842 * chain, and it would be charged from the transferred assets. If set1843 * below requirements, the execution may fail and assets wouldn't be1844 * received.1845 * 1846 * It's a no-op if any error on local XCM execution or message sending.1847 * Note sending assets out per se doesn't guarantee they would be1848 * received. Receiving depends on if the XCM message could be delivered1849 * by the network, and if the receiving chain would handle1850 * messages correctly.1851 **/1852 transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1853 /**1854 * Transfer several `MultiAsset` specifying the item to be used as fee1855 * 1856 * `dest_weight_limit` is the weight for XCM execution on the dest1857 * chain, and it would be charged from the transferred assets. If set1858 * below requirements, the execution may fail and assets wouldn't be1859 * received.1860 * 1861 * `fee_item` is index of the MultiAssets that we want to use for1862 * payment1863 * 1864 * It's a no-op if any error on local XCM execution or message sending.1865 * Note sending assets out per se doesn't guarantee they would be1866 * received. Receiving depends on if the XCM message could be delivered1867 * by the network, and if the receiving chain would handle1868 * messages correctly.1869 **/1870 transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1871 /**1872 * Transfer `MultiAsset` specifying the fee and amount as separate.1873 * 1874 * `dest_weight_limit` is the weight for XCM execution on the dest1875 * chain, and it would be charged from the transferred assets. If set1876 * below requirements, the execution may fail and assets wouldn't be1877 * received.1878 * 1879 * `fee` is the multiasset to be spent to pay for execution in1880 * destination chain. Both fee and amount will be subtracted form the1881 * callers balance For now we only accept fee and asset having the same1882 * `MultiLocation` id.1883 * 1884 * If `fee` is not high enough to cover for the execution costs in the1885 * destination chain, then the assets will be trapped in the1886 * destination chain1887 * 1888 * It's a no-op if any error on local XCM execution or message sending.1889 * Note sending assets out per se doesn't guarantee they would be1890 * received. Receiving depends on if the XCM message could be delivered1891 * by the network, and if the receiving chain would handle1892 * messages correctly.1893 **/1894 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, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1895 /**1896 * Transfer several currencies specifying the item to be used as fee1897 * 1898 * `dest_weight_limit` is the weight for XCM execution on the dest1899 * chain, and it would be charged from the transferred assets. If set1900 * below requirements, the execution may fail and assets wouldn't be1901 * received.1902 * 1903 * `fee_item` is index of the currencies tuple that we want to use for1904 * payment1905 * 1906 * It's a no-op if any error on local XCM execution or message sending.1907 * Note sending assets out per se doesn't guarantee they would be1908 * received. Receiving depends on if the XCM message could be delivered1909 * by the network, and if the receiving chain would handle1910 * messages correctly.1911 **/1912 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, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1913 /**1914 * Transfer native currencies specifying the fee and amount as1915 * separate.1916 * 1917 * `dest_weight_limit` is the weight for XCM execution on the dest1918 * chain, and it would be charged from the transferred assets. If set1919 * below requirements, the execution may fail and assets wouldn't be1920 * received.1921 * 1922 * `fee` is the amount to be spent to pay for execution in destination1923 * chain. Both fee and amount will be subtracted form the callers1924 * balance.1925 * 1926 * If `fee` is not high enough to cover for the execution costs in the1927 * destination chain, then the assets will be trapped in the1928 * destination chain1929 * 1930 * It's a no-op if any error on local XCM execution or message sending.1931 * Note sending assets out per se doesn't guarantee they would be1932 * received. Receiving depends on if the XCM message could be delivered1933 * by the network, and if the receiving chain would handle1934 * messages correctly.1935 **/1936 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, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1937 /**1938 * Generic tx1939 **/1940 [key: string]: SubmittableExtrinsicFunction<ApiType>;1941 };1942 } // AugmentedSubmittables1943} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts106.7 KiBsourcehistory