1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11<<<<<<< HEAD12<<<<<<< HEAD13import type { AccountId32, Call, H160, H256, MultiAddress, Permill } from '@polkadot/types/interfaces/runtime';14=======15<<<<<<< HEAD16import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';17>>>>>>> chore: regenerate types18=======19import type { AccountId32, Call, H160, H256, MultiAddress, Permill } from '@polkadot/types/interfaces/runtime';20>>>>>>> chore: regenerate types21import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, 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';2223export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;24export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;25export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;2627declare module '@polkadot/api-base/types/submittable' {28 interface AugmentedSubmittables<ApiType extends ApiTypes> {29 appPromotion: {30 /**31 * Recalculates interest for the specified number of stakers.32 * If all stakers are not recalculated, the next call of the extrinsic33 * will continue the recalculation, from those stakers for whom this34 * was not perform in last call.35 * 36 * # Permissions37 * 38 * * Pallet admin39 * 40 * # Arguments41 * 42 * * `stakers_number`: the number of stakers for which recalculation will be performed43 **/44 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;45 /**46 * Sets an address as the the admin.47 * 48 * # Permissions49 * 50 * * Sudo51 * 52 * # Arguments53 * 54 * * `admin`: account of the new admin.55 **/56 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;57 /**58 * Sets the pallet to be the sponsor for the collection.59 * 60 * # Permissions61 * 62 * * Pallet admin63 * 64 * # Arguments65 * 66 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`67 **/68 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;69 /**70 * Sets the pallet to be the sponsor for the contract.71 * 72 * # Permissions73 * 74 * * Pallet admin75 * 76 * # Arguments77 * 78 * * `contract_id`: the contract address that will be sponsored by `pallet_id`79 **/80 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;81 /**82 * Stakes the amount of native tokens.83 * Sets `amount` to the locked state.84 * The maximum number of stakes for a staker is 10.85 * 86 * # Arguments87 * 88 * * `amount`: in native tokens.89 **/90 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;91 /**92 * Removes the pallet as the sponsor for the collection.93 * Returns [`NoPermission`][`Error::NoPermission`]94 * if the pallet wasn't the sponsor.95 * 96 * # Permissions97 * 98 * * Pallet admin99 * 100 * # Arguments101 * 102 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`103 **/104 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;105 /**106 * Removes the pallet as the sponsor for the contract.107 * Returns [`NoPermission`][`Error::NoPermission`]108 * if the pallet wasn't the sponsor.109 * 110 * # Permissions111 * 112 * * Pallet admin113 * 114 * # Arguments115 * 116 * * `contract_id`: the contract address that is sponsored by `pallet_id`117 **/118 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;119 /**120 * Unstakes all stakes.121 * Moves the sum of all stakes to the `reserved` state.122 * After the end of `PendingInterval` this sum becomes completely123 * free for further use.124 **/125 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;126 /**127 * Generic tx128 **/129 [key: string]: SubmittableExtrinsicFunction<ApiType>;130 };131 balances: {132 /**133 * Exactly as `transfer`, except the origin must be root and the source account may be134 * specified.135 * # <weight>136 * - Same as transfer, but additional read and write because the source account is not137 * assumed to be in the overlay.138 * # </weight>139 **/140 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>]>;141 /**142 * Unreserve some balance from a user by force.143 * 144 * Can only be called by ROOT.145 **/146 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;147 /**148 * Set the balances of a given account.149 * 150 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will151 * also alter the total issuance of the system (`TotalIssuance`) appropriately.152 * If the new free or reserved balance is below the existential deposit,153 * it will reset the account nonce (`frame_system::AccountNonce`).154 * 155 * The dispatch origin for this call is `root`.156 **/157 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>]>;158 /**159 * Transfer some liquid free balance to another account.160 * 161 * `transfer` will set the `FreeBalance` of the sender and receiver.162 * If the sender's account is below the existential deposit as a result163 * of the transfer, the account will be reaped.164 * 165 * The dispatch origin for this call must be `Signed` by the transactor.166 * 167 * # <weight>168 * - Dependent on arguments but not critical, given proper implementations for input config169 * types. See related functions below.170 * - It contains a limited number of reads and writes internally and no complex171 * computation.172 * 173 * Related functions:174 * 175 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.176 * - Transferring balances to accounts that did not exist before will cause177 * `T::OnNewAccount::on_new_account` to be called.178 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.179 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check180 * that the transfer will not kill the origin account.181 * ---------------------------------182 * - Origin account is already in memory, so no DB operations for them.183 * # </weight>184 **/185 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>]>;186 /**187 * Transfer the entire transferable balance from the caller account.188 * 189 * NOTE: This function only attempts to transfer _transferable_ balances. This means that190 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be191 * transferred by this function. To ensure that this function results in a killed account,192 * you might need to prepare the account by removing any reference counters, storage193 * deposits, etc...194 * 195 * The dispatch origin of this call must be Signed.196 * 197 * - `dest`: The recipient of the transfer.198 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all199 * of the funds the account has, causing the sender account to be killed (false), or200 * transfer everything except at least the existential deposit, which will guarantee to201 * keep the sender account alive (true). # <weight>202 * - O(1). Just like transfer, but reading the user's transferable balance first.203 * #</weight>204 **/205 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;206 /**207 * Same as the [`transfer`] call, but with a check that the transfer will not kill the208 * origin account.209 * 210 * 99% of the time you want [`transfer`] instead.211 * 212 * [`transfer`]: struct.Pallet.html#method.transfer213 **/214 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>]>;215 /**216 * Generic tx217 **/218 [key: string]: SubmittableExtrinsicFunction<ApiType>;219 };220 charging: {221 /**222 * Generic tx223 **/224 [key: string]: SubmittableExtrinsicFunction<ApiType>;225 };226 configuration: {227 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;228 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;229 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;230 setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;231 /**232 * Generic tx233 **/234 [key: string]: SubmittableExtrinsicFunction<ApiType>;235 };236 cumulusXcm: {237 /**238 * Generic tx239 **/240 [key: string]: SubmittableExtrinsicFunction<ApiType>;241 };242 dmpQueue: {243 /**244 * Service a single overweight message.245 * 246 * - `origin`: Must pass `ExecuteOverweightOrigin`.247 * - `index`: The index of the overweight message to service.248 * - `weight_limit`: The amount of weight that message execution may take.249 * 250 * Errors:251 * - `Unknown`: Message of `index` is unknown.252 * - `OverLimit`: Message execution may use greater than `weight_limit`.253 * 254 * Events:255 * - `OverweightServiced`: On success.256 **/257 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;258 /**259 * Generic tx260 **/261 [key: string]: SubmittableExtrinsicFunction<ApiType>;262 };263 ethereum: {264 /**265 * Transact an Ethereum transaction.266 **/267 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;268 /**269 * Generic tx270 **/271 [key: string]: SubmittableExtrinsicFunction<ApiType>;272 };273 evm: {274 /**275 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.276 **/277 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>]>>]>;278 /**279 * Issue an EVM create operation. This is similar to a contract creation transaction in280 * Ethereum.281 **/282 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>]>>]>;283 /**284 * Issue an EVM create2 operation.285 **/286 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>]>>]>;287 /**288 * Withdraw balance from EVM into currency/balances pallet.289 **/290 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;291 /**292 * Generic tx293 **/294 [key: string]: SubmittableExtrinsicFunction<ApiType>;295 };296 evmMigration: {297 /**298 * Start contract migration, inserts contract stub at target address,299 * and marks account as pending, allowing to insert storage300 **/301 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;302 /**303 * Finish contract migration, allows it to be called.304 * It is not possible to alter contract storage via [`Self::set_data`]305 * after this call.306 **/307 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;308 /**309 * Create ethereum events attached to the fake transaction310 **/311 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;312 /**313 * Create substrate events314 **/315 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;316 /**317 * Insert items into contract storage, this method can be called318 * multiple times319 **/320 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;321 /**322 * Generic tx323 **/324 [key: string]: SubmittableExtrinsicFunction<ApiType>;325 };326 foreignAssets: {327 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]>;328 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]>;329 /**330 * Generic tx331 **/332 [key: string]: SubmittableExtrinsicFunction<ApiType>;333 };334 inflation: {335 /**336 * This method sets the inflation start date. Can be only called once.337 * Inflation start block can be backdated and will catch up. The method will create Treasury338 * account if it does not exist and perform the first inflation deposit.339 * 340 * # Permissions341 * 342 * * Root343 * 344 * # Arguments345 * 346 * * inflation_start_relay_block: The relay chain block at which inflation should start347 **/348 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;349 /**350 * Generic tx351 **/352 [key: string]: SubmittableExtrinsicFunction<ApiType>;353 };354 maintenance: {355 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;356 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;357 /**358 * Generic tx359 **/360 [key: string]: SubmittableExtrinsicFunction<ApiType>;361 };362 parachainSystem: {363 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;364 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;365 /**366 * Set the current validation data.367 * 368 * This should be invoked exactly once per block. It will panic at the finalization369 * phase if the call was not invoked.370 * 371 * The dispatch origin for this call must be `Inherent`372 * 373 * As a side effect, this function upgrades the current validation function374 * if the appropriate time has come.375 **/376 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;377 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;378 /**379 * Generic tx380 **/381 [key: string]: SubmittableExtrinsicFunction<ApiType>;382 };383 polkadotXcm: {384 /**385 * Execute an XCM message from a local, signed, origin.386 * 387 * An event is deposited indicating whether `msg` could be executed completely or only388 * partially.389 * 390 * No more than `max_weight` will be used in its attempted execution. If this is less than the391 * maximum amount of weight that the message could take to be executed, then no execution392 * attempt will be made.393 * 394 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully395 * to completion; only that *some* of it was executed.396 **/397 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;398 /**399 * Set a safe XCM version (the version that XCM should be encoded with if the most recent400 * version a destination can accept is unknown).401 * 402 * - `origin`: Must be Root.403 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.404 **/405 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;406 /**407 * Ask a location to notify us regarding their XCM version and any changes to it.408 * 409 * - `origin`: Must be Root.410 * - `location`: The location to which we should subscribe for XCM version notifications.411 **/412 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;413 /**414 * Require that a particular destination should no longer notify us regarding any XCM415 * version changes.416 * 417 * - `origin`: Must be Root.418 * - `location`: The location to which we are currently subscribed for XCM version419 * notifications which we no longer desire.420 **/421 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;422 /**423 * Extoll that a particular destination can be communicated with through a particular424 * version of XCM.425 * 426 * - `origin`: Must be Root.427 * - `location`: The destination that is being described.428 * - `xcm_version`: The latest version of XCM that `location` supports.429 **/430 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;431 /**432 * Transfer some assets from the local chain to the sovereign account of a destination433 * chain and forward a notification XCM.434 * 435 * Fee payment on the destination side is made from the asset in the `assets` vector of436 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight437 * is needed than `weight_limit`, then the operation will fail and the assets send may be438 * at risk.439 * 440 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.441 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send442 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.443 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be444 * an `AccountId32` value.445 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the446 * `dest` side.447 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay448 * fees.449 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.450 **/451 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]>;452 /**453 * Teleport some assets from the local chain to some destination chain.454 * 455 * Fee payment on the destination side is made from the asset in the `assets` vector of456 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight457 * is needed than `weight_limit`, then the operation will fail and the assets send may be458 * at risk.459 * 460 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.461 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send462 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.463 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be464 * an `AccountId32` value.465 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the466 * `dest` side. May not be empty.467 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay468 * fees.469 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.470 **/471 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]>;472 /**473 * Transfer some assets from the local chain to the sovereign account of a destination474 * chain and forward a notification XCM.475 * 476 * Fee payment on the destination side is made from the asset in the `assets` vector of477 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,478 * with all fees taken as needed from the asset.479 * 480 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.481 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send482 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.483 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be484 * an `AccountId32` value.485 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the486 * `dest` side.487 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay488 * fees.489 **/490 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]>;491 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;492 /**493 * Teleport some assets from the local chain to some destination chain.494 * 495 * Fee payment on the destination side is made from the asset in the `assets` vector of496 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,497 * with all fees taken as needed from the asset.498 * 499 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.500 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send501 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.502 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be503 * an `AccountId32` value.504 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the505 * `dest` side. May not be empty.506 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay507 * fees.508 **/509 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]>;510 /**511 * Generic tx512 **/513 [key: string]: SubmittableExtrinsicFunction<ApiType>;514 };515 rmrkCore: {516 /**517 * Accept an NFT sent from another account to self or an owned NFT.518 * 519 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.520 * 521 * # Permissions:522 * - Token-owner-to-be523 * 524 * # Arguments:525 * - `origin`: sender of the transaction526 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.527 * - `rmrk_nft_id`: ID of the NFT to be accepted.528 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,529 * whichever the accepted NFT was sent to.530 **/531 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;532 /**533 * Accept the addition of a newly created pending resource to an existing NFT.534 * 535 * This transaction is needed when a resource is created and assigned to an NFT536 * by a non-owner, i.e. the collection issuer, with one of the537 * [`add_...` transactions](Pallet::add_basic_resource).538 * 539 * # Permissions:540 * - Token owner541 * 542 * # Arguments:543 * - `origin`: sender of the transaction544 * - `rmrk_collection_id`: RMRK collection ID of the NFT.545 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.546 * - `resource_id`: ID of the newly created pending resource.547 * accept the addition of a new resource to an existing NFT548 **/549 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;550 /**551 * Accept the removal of a removal-pending resource from an NFT.552 * 553 * This transaction is needed when a non-owner, i.e. the collection issuer,554 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.555 * 556 * # Permissions:557 * - Token owner558 * 559 * # Arguments:560 * - `origin`: sender of the transaction561 * - `rmrk_collection_id`: RMRK collection ID of the NFT.562 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.563 * - `resource_id`: ID of the removal-pending resource.564 **/565 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;566 /**567 * Create and set/propose a basic resource for an NFT.568 * 569 * A basic resource is the simplest, lacking a Base and anything that comes with it.570 * See RMRK docs for more information and examples.571 * 572 * # Permissions:573 * - Collection issuer - if not the token owner, adding the resource will warrant574 * the owner's [acceptance](Pallet::accept_resource).575 * 576 * # Arguments:577 * - `origin`: sender of the transaction578 * - `rmrk_collection_id`: RMRK collection ID of the NFT.579 * - `nft_id`: ID of the NFT to assign a resource to.580 * - `resource`: Data of the resource to be created.581 **/582 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]>;583 /**584 * Create and set/propose a composable resource for an NFT.585 * 586 * A composable resource links to a Base and has a subset of its Parts it is composed of.587 * See RMRK docs for more information and examples.588 * 589 * # Permissions:590 * - Collection issuer - if not the token owner, adding the resource will warrant591 * the owner's [acceptance](Pallet::accept_resource).592 * 593 * # Arguments:594 * - `origin`: sender of the transaction595 * - `rmrk_collection_id`: RMRK collection ID of the NFT.596 * - `nft_id`: ID of the NFT to assign a resource to.597 * - `resource`: Data of the resource to be created.598 **/599 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]>;600 /**601 * Create and set/propose a slot resource for an NFT.602 * 603 * A slot resource links to a Base and a slot ID in it which it can fit into.604 * See RMRK docs for more information and examples.605 * 606 * # Permissions:607 * - Collection issuer - if not the token owner, adding the resource will warrant608 * the owner's [acceptance](Pallet::accept_resource).609 * 610 * # Arguments:611 * - `origin`: sender of the transaction612 * - `rmrk_collection_id`: RMRK collection ID of the NFT.613 * - `nft_id`: ID of the NFT to assign a resource to.614 * - `resource`: Data of the resource to be created.615 **/616 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]>;617 /**618 * Burn an NFT, destroying it and its nested tokens up to the specified limit.619 * If the burning budget is exceeded, the transaction is reverted.620 * 621 * This is the way to burn a nested token as well.622 * 623 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).624 * 625 * # Permissions:626 * * Token owner627 * 628 * # Arguments:629 * - `origin`: sender of the transaction630 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.631 * - `nft_id`: ID of the NFT to be destroyed.632 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction633 * is reverted if there are more tokens to burn in the nesting tree than this number.634 * This is primarily a mechanism of transaction weight control.635 **/636 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;637 /**638 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).639 * 640 * # Permissions:641 * * Collection issuer642 * 643 * # Arguments:644 * - `origin`: sender of the transaction645 * - `collection_id`: RMRK collection ID to change the issuer of.646 * - `new_issuer`: Collection's new issuer.647 **/648 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;649 /**650 * Create a new collection of NFTs.651 * 652 * # Permissions:653 * * Anyone - will be assigned as the issuer of the collection.654 * 655 * # Arguments:656 * - `origin`: sender of the transaction657 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.658 * - `max`: Optional maximum number of tokens.659 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.660 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.661 **/662 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;663 /**664 * Destroy a collection.665 * 666 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.667 * 668 * # Permissions:669 * * Collection issuer670 * 671 * # Arguments:672 * - `origin`: sender of the transaction673 * - `collection_id`: RMRK ID of the collection to destroy.674 **/675 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;676 /**677 * "Lock" the collection and prevent new token creation. Cannot be undone.678 * 679 * # Permissions:680 * * Collection issuer681 * 682 * # Arguments:683 * - `origin`: sender of the transaction684 * - `collection_id`: RMRK ID of the collection to lock.685 **/686 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;687 /**688 * Mint an NFT in a specified collection.689 * 690 * # Permissions:691 * * Collection issuer692 * 693 * # Arguments:694 * - `origin`: sender of the transaction695 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).696 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.697 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.698 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.699 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.700 * - `transferable`: Can this NFT be transferred? Cannot be changed.701 * - `resources`: Resource data to be added to the NFT immediately after minting.702 **/703 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>>]>;704 /**705 * Reject an NFT sent from another account to self or owned NFT.706 * The NFT in question will not be sent back and burnt instead.707 * 708 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.709 * 710 * # Permissions:711 * - Token-owner-to-be-not712 * 713 * # Arguments:714 * - `origin`: sender of the transaction715 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.716 * - `rmrk_nft_id`: ID of the NFT to be rejected.717 **/718 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;719 /**720 * Remove and erase a resource from an NFT.721 * 722 * If the sender does not own the NFT, then it will be pending confirmation,723 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.724 * 725 * # Permissions726 * - Collection issuer727 * 728 * # Arguments729 * - `origin`: sender of the transaction730 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.731 * - `nft_id`: ID of the NFT with a resource to be removed.732 * - `resource_id`: ID of the resource to be removed.733 **/734 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;735 /**736 * Transfer an NFT from an account/NFT A to another account/NFT B.737 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].738 * 739 * If the target owner is an NFT owned by another account, then the NFT will enter740 * the pending state and will have to be accepted by the other account.741 * 742 * # Permissions:743 * - Token owner744 * 745 * # Arguments:746 * - `origin`: sender of the transaction747 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.748 * - `rmrk_nft_id`: ID of the NFT to be transferred.749 * - `new_owner`: New owner of the nft which can be either an account or a NFT.750 **/751 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;752 /**753 * Set a different order of resource priorities for an NFT. Priorities can be used,754 * for example, for order of rendering.755 * 756 * Note that the priorities are not updated automatically, and are an empty vector757 * by default. There is no pre-set definition for the order to be particular,758 * it can be interpreted arbitrarily use-case by use-case.759 * 760 * # Permissions:761 * - Token owner762 * 763 * # Arguments:764 * - `origin`: sender of the transaction765 * - `rmrk_collection_id`: RMRK collection ID of the NFT.766 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.767 * - `priorities`: Ordered vector of resource IDs.768 **/769 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;770 /**771 * Add or edit a custom user property, a key-value pair, describing the metadata772 * of a token or a collection, on either one of these.773 * 774 * Note that in this proxy implementation many details regarding RMRK are stored775 * as scoped properties prefixed with "rmrk:", normally inaccessible776 * to external transactions and RPCs.777 * 778 * # Permissions:779 * - Collection issuer - in case of collection property780 * - Token owner - in case of NFT property781 * 782 * # Arguments:783 * - `origin`: sender of the transaction784 * - `rmrk_collection_id`: RMRK collection ID.785 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.786 * - `key`: Key of the custom property to be referenced by.787 * - `value`: Value of the custom property to be stored.788 **/789 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]>;790 /**791 * Generic tx792 **/793 [key: string]: SubmittableExtrinsicFunction<ApiType>;794 };795 rmrkEquip: {796 /**797 * Create a new Base.798 * 799 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)800 * 801 * # Permissions802 * - Anyone - will be assigned as the issuer of the Base.803 * 804 * # Arguments:805 * - `origin`: Caller, will be assigned as the issuer of the Base806 * - `base_type`: Arbitrary media type, e.g. "svg".807 * - `symbol`: Arbitrary client-chosen symbol.808 * - `parts`: Array of Fixed and Slot Parts composing the Base,809 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).810 **/811 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>]>;812 /**813 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.814 * 815 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).816 * 817 * # Permissions:818 * - Base issuer819 * 820 * # Arguments:821 * - `origin`: sender of the transaction822 * - `base_id`: Base containing the Slot Part to be updated.823 * - `slot_id`: Slot Part whose Equippable List is being updated .824 * - `equippables`: List of equippables that will override the current Equippables list.825 **/826 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]>;827 /**828 * Add a Theme to a Base.829 * A Theme named "default" is required prior to adding other Themes.830 * 831 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).832 * 833 * # Permissions:834 * - Base issuer835 * 836 * # Arguments:837 * - `origin`: sender of the transaction838 * - `base_id`: Base ID containing the Theme to be updated.839 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an840 * array of [key, value, inherit].841 * - `key`: Arbitrary BoundedString, defined by client.842 * - `value`: Arbitrary BoundedString, defined by client.843 * - `inherit`: Optional bool.844 **/845 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;846 /**847 * Generic tx848 **/849 [key: string]: SubmittableExtrinsicFunction<ApiType>;850 };851 structure: {852 /**853 * Generic tx854 **/855 [key: string]: SubmittableExtrinsicFunction<ApiType>;856 };857 sudo: {858 /**859 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo860 * key.861 * 862 * The dispatch origin for this call must be _Signed_.863 * 864 * # <weight>865 * - O(1).866 * - Limited storage reads.867 * - One DB change.868 * # </weight>869 **/870 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;871 /**872 * Authenticates the sudo key and dispatches a function call with `Root` origin.873 * 874 * The dispatch origin for this call must be _Signed_.875 * 876 * # <weight>877 * - O(1).878 * - Limited storage reads.879 * - One DB write (event).880 * - Weight of derivative `call` execution + 10,000.881 * # </weight>882 **/883 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;884 /**885 * Authenticates the sudo key and dispatches a function call with `Signed` origin from886 * a given account.887 * 888 * The dispatch origin for this call must be _Signed_.889 * 890 * # <weight>891 * - O(1).892 * - Limited storage reads.893 * - One DB write (event).894 * - Weight of derivative `call` execution + 10,000.895 * # </weight>896 **/897 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]>;898 /**899 * Authenticates the sudo key and dispatches a function call with `Root` origin.900 * This function does not check the weight of the call, and instead allows the901 * Sudo user to specify the weight of the call.902 * 903 * The dispatch origin for this call must be _Signed_.904 * 905 * # <weight>906 * - O(1).907 * - The weight of this call is defined by the caller.908 * # </weight>909 **/910 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;911 /**912 * Generic tx913 **/914 [key: string]: SubmittableExtrinsicFunction<ApiType>;915 };916 system: {917 /**918 * Kill all storage items with a key that starts with the given prefix.919 * 920 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under921 * the prefix we are removing to accurately calculate the weight of this function.922 **/923 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;924 /**925 * Kill some items from storage.926 **/927 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;928 /**929 * Make some on-chain remark.930 * 931 * # <weight>932 * - `O(1)`933 * # </weight>934 **/935 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;936 /**937 * Make some on-chain remark and emit event.938 **/939 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;940 /**941 * Set the new runtime code.942 * 943 * # <weight>944 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`945 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is946 * expensive).947 * - 1 storage write (codec `O(C)`).948 * - 1 digest item.949 * - 1 event.950 * The weight of this function is dependent on the runtime, but generally this is very951 * expensive. We will treat this as a full block.952 * # </weight>953 **/954 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;955 /**956 * Set the new runtime code without doing any checks of the given `code`.957 * 958 * # <weight>959 * - `O(C)` where `C` length of `code`960 * - 1 storage write (codec `O(C)`).961 * - 1 digest item.962 * - 1 event.963 * The weight of this function is dependent on the runtime. We will treat this as a full964 * block. # </weight>965 **/966 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;967 /**968 * Set the number of pages in the WebAssembly environment's heap.969 **/970 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;971 /**972 * Set some items of storage.973 **/974 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;975 /**976 * Generic tx977 **/978 [key: string]: SubmittableExtrinsicFunction<ApiType>;979 };980 testUtils: {981 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;982 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;983 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;984 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;985 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;986 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;987 /**988 * Generic tx989 **/990 [key: string]: SubmittableExtrinsicFunction<ApiType>;991 };992 timestamp: {993 /**994 * Set the current time.995 * 996 * This call should be invoked exactly once per block. It will panic at the finalization997 * phase, if this call hasn't been invoked by that time.998 * 999 * The timestamp should be greater than the previous one by the amount specified by1000 * `MinimumPeriod`.1001 * 1002 * The dispatch origin for this call must be `Inherent`.1003 * 1004 * # <weight>1005 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1006 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1007 * `on_finalize`)1008 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1009 * # </weight>1010 **/1011 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1012 /**1013 * Generic tx1014 **/1015 [key: string]: SubmittableExtrinsicFunction<ApiType>;1016 };1017 tokens: {1018 /**1019 * Exactly as `transfer`, except the origin must be root and the source1020 * account may be specified.1021 * 1022 * The dispatch origin for this call must be _Root_.1023 * 1024 * - `source`: The sender of the transfer.1025 * - `dest`: The recipient of the transfer.1026 * - `currency_id`: currency type.1027 * - `amount`: free balance amount to tranfer.1028 **/1029 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>]>;1030 /**1031 * Set the balances of a given account.1032 * 1033 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1034 * will also decrease the total issuance of the system1035 * (`TotalIssuance`). If the new free or reserved balance is below the1036 * existential deposit, it will reap the `AccountInfo`.1037 * 1038 * The dispatch origin for this call is `root`.1039 **/1040 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>]>;1041 /**1042 * Transfer some liquid free balance to another account.1043 * 1044 * `transfer` will set the `FreeBalance` of the sender and receiver.1045 * It will decrease the total issuance of the system by the1046 * `TransferFee`. If the sender's account is below the existential1047 * deposit as a result of the transfer, the account will be reaped.1048 * 1049 * The dispatch origin for this call must be `Signed` by the1050 * transactor.1051 * 1052 * - `dest`: The recipient of the transfer.1053 * - `currency_id`: currency type.1054 * - `amount`: free balance amount to tranfer.1055 **/1056 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>]>;1057 /**1058 * Transfer all remaining balance to the given account.1059 * 1060 * NOTE: This function only attempts to transfer _transferable_1061 * balances. This means that any locked, reserved, or existential1062 * deposits (when `keep_alive` is `true`), will not be transferred by1063 * this function. To ensure that this function results in a killed1064 * account, you might need to prepare the account by removing any1065 * reference counters, storage deposits, etc...1066 * 1067 * The dispatch origin for this call must be `Signed` by the1068 * transactor.1069 * 1070 * - `dest`: The recipient of the transfer.1071 * - `currency_id`: currency type.1072 * - `keep_alive`: A boolean to determine if the `transfer_all`1073 * operation should send all of the funds the account has, causing1074 * the sender account to be killed (false), or transfer everything1075 * except at least the existential deposit, which will guarantee to1076 * keep the sender account alive (true).1077 **/1078 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]>;1079 /**1080 * Same as the [`transfer`] call, but with a check that the transfer1081 * will not kill the origin account.1082 * 1083 * 99% of the time you want [`transfer`] instead.1084 * 1085 * The dispatch origin for this call must be `Signed` by the1086 * transactor.1087 * 1088 * - `dest`: The recipient of the transfer.1089 * - `currency_id`: currency type.1090 * - `amount`: free balance amount to tranfer.1091 **/1092 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>]>;1093 /**1094 * Generic tx1095 **/1096 [key: string]: SubmittableExtrinsicFunction<ApiType>;1097 };1098 treasury: {1099 /**1100 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1101 * and the original deposit will be returned.1102 * 1103 * May only be called from `T::ApproveOrigin`.1104 * 1105 * # <weight>1106 * - Complexity: O(1).1107 * - DbReads: `Proposals`, `Approvals`1108 * - DbWrite: `Approvals`1109 * # </weight>1110 **/1111 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1112 /**1113 * Put forward a suggestion for spending. A deposit proportional to the value1114 * is reserved and slashed if the proposal is rejected. It is returned once the1115 * proposal is awarded.1116 * 1117 * # <weight>1118 * - Complexity: O(1)1119 * - DbReads: `ProposalCount`, `origin account`1120 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1121 * # </weight>1122 **/1123 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]>;1124 /**1125 * Reject a proposed spend. The original deposit will be slashed.1126 * 1127 * May only be called from `T::RejectOrigin`.1128 * 1129 * # <weight>1130 * - Complexity: O(1)1131 * - DbReads: `Proposals`, `rejected proposer account`1132 * - DbWrites: `Proposals`, `rejected proposer account`1133 * # </weight>1134 **/1135 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1136 /**1137 * Force a previously approved proposal to be removed from the approval queue.1138 * The original deposit will no longer be returned.1139 * 1140 * May only be called from `T::RejectOrigin`.1141 * - `proposal_id`: The index of a proposal1142 * 1143 * # <weight>1144 * - Complexity: O(A) where `A` is the number of approvals1145 * - Db reads and writes: `Approvals`1146 * # </weight>1147 * 1148 * Errors:1149 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1150 * i.e., the proposal has not been approved. This could also mean the proposal does not1151 * exist altogether, thus there is no way it would have been approved in the first place.1152 **/1153 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1154 /**1155 * Propose and approve a spend of treasury funds.1156 * 1157 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1158 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1159 * - `beneficiary`: The destination account for the transfer.1160 * 1161 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1162 * beneficiary.1163 **/1164 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]>;1165 /**1166 * Generic tx1167 **/1168 [key: string]: SubmittableExtrinsicFunction<ApiType>;1169 };1170 unique: {1171 /**1172 * Add an admin to a collection.1173 * 1174 * NFT Collection can be controlled by multiple admin addresses1175 * (some which can also be servers, for example). Admins can issue1176 * and burn NFTs, as well as add and remove other admins,1177 * but cannot change NFT or Collection ownership.1178 * 1179 * # Permissions1180 * 1181 * * Collection owner1182 * * Collection admin1183 * 1184 * # Arguments1185 * 1186 * * `collection_id`: ID of the Collection to add an admin for.1187 * * `new_admin`: Address of new admin to add.1188 **/1189 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1190 /**1191 * Add an address to allow list.1192 * 1193 * # Permissions1194 * 1195 * * Collection owner1196 * * Collection admin1197 * 1198 * # Arguments1199 * 1200 * * `collection_id`: ID of the modified collection.1201 * * `address`: ID of the address to be added to the allowlist.1202 **/1203 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1204 /**1205 * Allow a non-permissioned address to transfer or burn an item.1206 * 1207 * # Permissions1208 * 1209 * * Collection owner1210 * * Collection admin1211 * * Current item owner1212 * 1213 * # Arguments1214 * 1215 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1216 * * `collection_id`: ID of the collection the item belongs to.1217 * * `item_id`: ID of the item transactions on which are now approved.1218 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1219 * Set to 0 to revoke the approval.1220 **/1221 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]>;1222 /**1223 * Destroy a token on behalf of the owner as a non-owner account.1224 * 1225 * See also: [`approve`][`Pallet::approve`].1226 * 1227 * After this method executes, one approval is removed from the total so that1228 * the approved address will not be able to transfer this item again from this owner.1229 * 1230 * # Permissions1231 * 1232 * * Collection owner1233 * * Collection admin1234 * * Current token owner1235 * * Address approved by current item owner1236 * 1237 * # Arguments1238 * 1239 * * `from`: The owner of the burning item.1240 * * `collection_id`: ID of the collection to which the item belongs.1241 * * `item_id`: ID of item to burn.1242 * * `value`: Number of pieces to burn.1243 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1244 * * Fungible Mode: The desired number of pieces to burn.1245 * * Re-Fungible Mode: The desired number of pieces to burn.1246 **/1247 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]>;1248 /**1249 * Destroy an item.1250 * 1251 * # Permissions1252 * 1253 * * Collection owner1254 * * Collection admin1255 * * Current item owner1256 * 1257 * # Arguments1258 * 1259 * * `collection_id`: ID of the collection to which the item belongs.1260 * * `item_id`: ID of item to burn.1261 * * `value`: Number of pieces of the item to destroy.1262 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1263 * * Fungible Mode: The desired number of pieces to burn.1264 * * Re-Fungible Mode: The desired number of pieces to burn.1265 **/1266 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1267 /**1268 * Change the owner of the collection.1269 * 1270 * # Permissions1271 * 1272 * * Collection owner1273 * 1274 * # Arguments1275 * 1276 * * `collection_id`: ID of the modified collection.1277 * * `new_owner`: ID of the account that will become the owner.1278 **/1279 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1280 /**1281 * Confirm own sponsorship of a collection, becoming the sponsor.1282 * 1283 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1284 * Sponsor can pay the fees of a transaction instead of the sender,1285 * but only within specified limits.1286 * 1287 * # Permissions1288 * 1289 * * Sponsor-to-be1290 * 1291 * # Arguments1292 * 1293 * * `collection_id`: ID of the collection with the pending sponsor.1294 **/1295 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1296 /**1297 * Create a collection of tokens.1298 * 1299 * Each Token may have multiple properties encoded as an array of bytes1300 * of certain length. The initial owner of the collection is set1301 * to the address that signed the transaction and can be changed later.1302 * 1303 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1304 * 1305 * # Permissions1306 * 1307 * * Anyone - becomes the owner of the new collection.1308 * 1309 * # Arguments1310 * 1311 * * `collection_name`: Wide-character string with collection name1312 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1313 * * `collection_description`: Wide-character string with collection description1314 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1315 * * `token_prefix`: Byte string containing the token prefix to mark a collection1316 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1317 * * `mode`: Type of items stored in the collection and type dependent data.1318 **/1319 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]>;1320 /**1321 * Create a collection with explicit parameters.1322 * 1323 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1324 * 1325 * # Permissions1326 * 1327 * * Anyone - becomes the owner of the new collection.1328 * 1329 * # Arguments1330 * 1331 * * `data`: Explicit data of a collection used for its creation.1332 **/1333 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]>;1334 /**1335 * Mint an item within a collection.1336 * 1337 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1338 * 1339 * # Permissions1340 * 1341 * * Collection owner1342 * * Collection admin1343 * * Anyone if1344 * * Allow List is enabled, and1345 * * Address is added to allow list, and1346 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1347 * 1348 * # Arguments1349 * 1350 * * `collection_id`: ID of the collection to which an item would belong.1351 * * `owner`: Address of the initial owner of the item.1352 * * `data`: Token data describing the item to store on chain.1353 **/1354 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]>;1355 /**1356 * Create multiple items within a collection.1357 * 1358 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1359 * 1360 * # Permissions1361 * 1362 * * Collection owner1363 * * Collection admin1364 * * Anyone if1365 * * Allow List is enabled, and1366 * * Address is added to the allow list, and1367 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1368 * 1369 * # Arguments1370 * 1371 * * `collection_id`: ID of the collection to which the tokens would belong.1372 * * `owner`: Address of the initial owner of the tokens.1373 * * `items_data`: Vector of data describing each item to be created.1374 **/1375 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>]>;1376 /**1377 * Create multiple items within a collection with explicitly specified initial parameters.1378 * 1379 * # Permissions1380 * 1381 * * Collection owner1382 * * Collection admin1383 * * Anyone if1384 * * Allow List is enabled, and1385 * * Address is added to allow list, and1386 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1387 * 1388 * # Arguments1389 * 1390 * * `collection_id`: ID of the collection to which the tokens would belong.1391 * * `data`: Explicit item creation data.1392 **/1393 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1394 /**1395 * Delete specified collection properties.1396 * 1397 * # Permissions1398 * 1399 * * Collection Owner1400 * * Collection Admin1401 * 1402 * # Arguments1403 * 1404 * * `collection_id`: ID of the modified collection.1405 * * `property_keys`: Vector of keys of the properties to be deleted.1406 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1407 **/1408 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1409 /**1410 * Delete specified token properties. Currently properties only work with NFTs.1411 * 1412 * # Permissions1413 * 1414 * * Depends on collection's token property permissions and specified property mutability:1415 * * Collection owner1416 * * Collection admin1417 * * Token owner1418 * 1419 * # Arguments1420 * 1421 * * `collection_id`: ID of the collection to which the token belongs.1422 * * `token_id`: ID of the modified token.1423 * * `property_keys`: Vector of keys of the properties to be deleted.1424 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1425 **/1426 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1427 /**1428 * Destroy a collection if no tokens exist within.1429 * 1430 * # Permissions1431 * 1432 * * Collection owner1433 * 1434 * # Arguments1435 * 1436 * * `collection_id`: Collection to destroy.1437 **/1438 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1439 /**1440 * Repairs a collection if the data was somehow corrupted.1441 * 1442 * # Arguments1443 * 1444 * * `collection_id`: ID of the collection to repair.1445 **/1446 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1447 /**1448 * Repairs a token if the data was somehow corrupted.1449 * 1450 * # Arguments1451 * 1452 * * `collection_id`: ID of the collection the item belongs to.1453 * * `item_id`: ID of the item.1454 **/1455 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1456 /**1457 * Remove admin of a collection.1458 * 1459 * An admin address can remove itself. List of admins may become empty,1460 * in which case only Collection Owner will be able to add an Admin.1461 * 1462 * # Permissions1463 * 1464 * * Collection owner1465 * * Collection admin1466 * 1467 * # Arguments1468 * 1469 * * `collection_id`: ID of the collection to remove the admin for.1470 * * `account_id`: Address of the admin to remove.1471 **/1472 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1473 /**1474 * Remove a collection's a sponsor, making everyone pay for their own transactions.1475 * 1476 * # Permissions1477 * 1478 * * Collection owner1479 * 1480 * # Arguments1481 * 1482 * * `collection_id`: ID of the collection with the sponsor to remove.1483 **/1484 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1485 /**1486 * Remove an address from allow list.1487 * 1488 * # Permissions1489 * 1490 * * Collection owner1491 * * Collection admin1492 * 1493 * # Arguments1494 * 1495 * * `collection_id`: ID of the modified collection.1496 * * `address`: ID of the address to be removed from the allowlist.1497 **/1498 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1499 /**1500 * Re-partition a refungible token, while owning all of its parts/pieces.1501 * 1502 * # Permissions1503 * 1504 * * Token owner (must own every part)1505 * 1506 * # Arguments1507 * 1508 * * `collection_id`: ID of the collection the RFT belongs to.1509 * * `token_id`: ID of the RFT.1510 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1511 **/1512 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1513 /**1514 * Sets or unsets the approval of a given operator.1515 * 1516 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1517 * 1518 * # Arguments1519 * 1520 * * `owner`: Token owner1521 * * `operator`: Operator1522 * * `approve`: Should operator status be granted or revoked?1523 **/1524 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1525 /**1526 * Set specific limits of a collection. Empty, or None fields mean chain default.1527 * 1528 * # Permissions1529 * 1530 * * Collection owner1531 * * Collection admin1532 * 1533 * # Arguments1534 * 1535 * * `collection_id`: ID of the modified collection.1536 * * `new_limit`: New limits of the collection. Fields that are not set (None)1537 * will not overwrite the old ones.1538 **/1539 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]>;1540 /**1541 * Set specific permissions of a collection. Empty, or None fields mean chain default.1542 * 1543 * # Permissions1544 * 1545 * * Collection owner1546 * * Collection admin1547 * 1548 * # Arguments1549 * 1550 * * `collection_id`: ID of the modified collection.1551 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1552 * will not overwrite the old ones.1553 **/1554 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1555 /**1556 * Add or change collection properties.1557 * 1558 * # Permissions1559 * 1560 * * Collection owner1561 * * Collection admin1562 * 1563 * # Arguments1564 * 1565 * * `collection_id`: ID of the modified collection.1566 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1567 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1568 **/1569 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1570 /**1571 * Set (invite) a new collection sponsor.1572 * 1573 * If successful, confirmation from the sponsor-to-be will be pending.1574 * 1575 * # Permissions1576 * 1577 * * Collection owner1578 * * Collection admin1579 * 1580 * # Arguments1581 * 1582 * * `collection_id`: ID of the modified collection.1583 * * `new_sponsor`: ID of the account of the sponsor-to-be.1584 **/1585 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1586 /**1587 * Add or change token properties according to collection's permissions.1588 * Currently properties only work with NFTs.1589 * 1590 * # Permissions1591 * 1592 * * Depends on collection's token property permissions and specified property mutability:1593 * * Collection owner1594 * * Collection admin1595 * * Token owner1596 * 1597 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1598 * 1599 * # Arguments1600 * 1601 * * `collection_id: ID of the collection to which the token belongs.1602 * * `token_id`: ID of the modified token.1603 * * `properties`: Vector of key-value pairs stored as the token's metadata.1604 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1605 **/1606 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>]>;1607 /**1608 * Add or change token property permissions of a collection.1609 * 1610 * Without a permission for a particular key, a property with that key1611 * cannot be created in a token.1612 * 1613 * # Permissions1614 * 1615 * * Collection owner1616 * * Collection admin1617 * 1618 * # Arguments1619 * 1620 * * `collection_id`: ID of the modified collection.1621 * * `property_permissions`: Vector of permissions for property keys.1622 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1623 **/1624 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1625 /**1626 * Completely allow or disallow transfers for a particular collection.1627 * 1628 * # Permissions1629 * 1630 * * Collection owner1631 * 1632 * # Arguments1633 * 1634 * * `collection_id`: ID of the collection.1635 * * `value`: New value of the flag, are transfers allowed?1636 **/1637 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1638 /**1639 * Change ownership of the token.1640 * 1641 * # Permissions1642 * 1643 * * Collection owner1644 * * Collection admin1645 * * Current token owner1646 * 1647 * # Arguments1648 * 1649 * * `recipient`: Address of token recipient.1650 * * `collection_id`: ID of the collection the item belongs to.1651 * * `item_id`: ID of the item.1652 * * Non-Fungible Mode: Required.1653 * * Fungible Mode: Ignored.1654 * * Re-Fungible Mode: Required.1655 * 1656 * * `value`: Amount to transfer.1657 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1658 * * Fungible Mode: The desired number of pieces to transfer.1659 * * Re-Fungible Mode: The desired number of pieces to transfer.1660 **/1661 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]>;1662 /**1663 * Change ownership of an item on behalf of the owner as a non-owner account.1664 * 1665 * See the [`approve`][`Pallet::approve`] method for additional information.1666 * 1667 * After this method executes, one approval is removed from the total so that1668 * the approved address will not be able to transfer this item again from this owner.1669 * 1670 * # Permissions1671 * 1672 * * Collection owner1673 * * Collection admin1674 * * Current item owner1675 * * Address approved by current item owner1676 * 1677 * # Arguments1678 * 1679 * * `from`: Address that currently owns the token.1680 * * `recipient`: Address of the new token-owner-to-be.1681 * * `collection_id`: ID of the collection the item.1682 * * `item_id`: ID of the item to be transferred.1683 * * `value`: Amount to transfer.1684 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1685 * * Fungible Mode: The desired number of pieces to transfer.1686 * * Re-Fungible Mode: The desired number of pieces to transfer.1687 **/1688 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]>;1689 /**1690 * Generic tx1691 **/1692 [key: string]: SubmittableExtrinsicFunction<ApiType>;1693 };1694 vesting: {1695 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1696 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1697 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>]>;1698 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]>;1699 /**1700 * Generic tx1701 **/1702 [key: string]: SubmittableExtrinsicFunction<ApiType>;1703 };1704 xcmpQueue: {1705 /**1706 * Resumes all XCM executions for the XCMP queue.1707 * 1708 * Note that this function doesn't change the status of the in/out bound channels.1709 * 1710 * - `origin`: Must pass `ControllerOrigin`.1711 **/1712 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1713 /**1714 * Services a single overweight XCM.1715 * 1716 * - `origin`: Must pass `ExecuteOverweightOrigin`.1717 * - `index`: The index of the overweight XCM to service1718 * - `weight_limit`: The amount of weight that XCM execution may take.1719 * 1720 * Errors:1721 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1722 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1723 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1724 * 1725 * Events:1726 * - `OverweightServiced`: On success.1727 **/1728 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1729 /**1730 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1731 * 1732 * - `origin`: Must pass `ControllerOrigin`.1733 **/1734 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1735 /**1736 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1737 * messages from the channel.1738 * 1739 * - `origin`: Must pass `Root`.1740 * - `new`: Desired value for `QueueConfigData.drop_threshold`1741 **/1742 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1743 /**1744 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1745 * message sending may recommence after it has been suspended.1746 * 1747 * - `origin`: Must pass `Root`.1748 * - `new`: Desired value for `QueueConfigData.resume_threshold`1749 **/1750 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1751 /**1752 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1753 * suspend their sending.1754 * 1755 * - `origin`: Must pass `Root`.1756 * - `new`: Desired value for `QueueConfigData.suspend_value`1757 **/1758 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1759 /**1760 * Overwrites the amount of remaining weight under which we stop processing messages.1761 * 1762 * - `origin`: Must pass `Root`.1763 * - `new`: Desired value for `QueueConfigData.threshold_weight`1764 **/1765 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1766 /**1767 * Overwrites the speed to which the available weight approaches the maximum weight.1768 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1769 * 1770 * - `origin`: Must pass `Root`.1771 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1772 **/1773 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1774 /**1775 * Overwrite the maximum amount of weight any individual message may consume.1776 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1777 * 1778 * - `origin`: Must pass `Root`.1779 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1780 **/1781 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1782 /**1783 * Generic tx1784 **/1785 [key: string]: SubmittableExtrinsicFunction<ApiType>;1786 };1787 xTokens: {1788 /**1789 * Transfer native currencies.1790 * 1791 * `dest_weight_limit` is the weight for XCM execution on the dest1792 * chain, and it would be charged from the transferred assets. If set1793 * below requirements, the execution may fail and assets wouldn't be1794 * received.1795 * 1796 * It's a no-op if any error on local XCM execution or message sending.1797 * Note sending assets out per se doesn't guarantee they would be1798 * received. Receiving depends on if the XCM message could be delivered1799 * by the network, and if the receiving chain would handle1800 * messages correctly.1801 **/1802 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]>;1803 /**1804 * Transfer `MultiAsset`.1805 * 1806 * `dest_weight_limit` is the weight for XCM execution on the dest1807 * chain, and it would be charged from the transferred assets. If set1808 * below requirements, the execution may fail and assets wouldn't be1809 * received.1810 * 1811 * It's a no-op if any error on local XCM execution or message sending.1812 * Note sending assets out per se doesn't guarantee they would be1813 * received. Receiving depends on if the XCM message could be delivered1814 * by the network, and if the receiving chain would handle1815 * messages correctly.1816 **/1817 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]>;1818 /**1819 * Transfer several `MultiAsset` specifying the item to be used as fee1820 * 1821 * `dest_weight_limit` is the weight for XCM execution on the dest1822 * chain, and it would be charged from the transferred assets. If set1823 * below requirements, the execution may fail and assets wouldn't be1824 * received.1825 * 1826 * `fee_item` is index of the MultiAssets that we want to use for1827 * payment1828 * 1829 * It's a no-op if any error on local XCM execution or message sending.1830 * Note sending assets out per se doesn't guarantee they would be1831 * received. Receiving depends on if the XCM message could be delivered1832 * by the network, and if the receiving chain would handle1833 * messages correctly.1834 **/1835 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]>;1836 /**1837 * Transfer `MultiAsset` specifying the fee and amount as separate.1838 * 1839 * `dest_weight_limit` is the weight for XCM execution on the dest1840 * chain, and it would be charged from the transferred assets. If set1841 * below requirements, the execution may fail and assets wouldn't be1842 * received.1843 * 1844 * `fee` is the multiasset to be spent to pay for execution in1845 * destination chain. Both fee and amount will be subtracted form the1846 * callers balance For now we only accept fee and asset having the same1847 * `MultiLocation` id.1848 * 1849 * If `fee` is not high enough to cover for the execution costs in the1850 * destination chain, then the assets will be trapped in the1851 * destination chain1852 * 1853 * It's a no-op if any error on local XCM execution or message sending.1854 * Note sending assets out per se doesn't guarantee they would be1855 * received. Receiving depends on if the XCM message could be delivered1856 * by the network, and if the receiving chain would handle1857 * messages correctly.1858 **/1859 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]>;1860 /**1861 * Transfer several currencies specifying the item to be used as fee1862 * 1863 * `dest_weight_limit` is the weight for XCM execution on the dest1864 * chain, and it would be charged from the transferred assets. If set1865 * below requirements, the execution may fail and assets wouldn't be1866 * received.1867 * 1868 * `fee_item` is index of the currencies tuple that we want to use for1869 * payment1870 * 1871 * It's a no-op if any error on local XCM execution or message sending.1872 * Note sending assets out per se doesn't guarantee they would be1873 * received. Receiving depends on if the XCM message could be delivered1874 * by the network, and if the receiving chain would handle1875 * messages correctly.1876 **/1877 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]>;1878 /**1879 * Transfer native currencies specifying the fee and amount as1880 * separate.1881 * 1882 * `dest_weight_limit` is the weight for XCM execution on the dest1883 * chain, and it would be charged from the transferred assets. If set1884 * below requirements, the execution may fail and assets wouldn't be1885 * received.1886 * 1887 * `fee` is the amount to be spent to pay for execution in destination1888 * chain. Both fee and amount will be subtracted form the callers1889 * balance.1890 * 1891 * If `fee` is not high enough to cover for the execution costs in the1892 * destination chain, then the assets will be trapped in the1893 * destination chain1894 * 1895 * It's a no-op if any error on local XCM execution or message sending.1896 * Note sending assets out per se doesn't guarantee they would be1897 * received. Receiving depends on if the XCM message could be delivered1898 * by the network, and if the receiving chain would handle1899 * messages correctly.1900 **/1901 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]>;1902 /**1903 * Generic tx1904 **/1905 [key: string]: SubmittableExtrinsicFunction<ApiType>;1906 };1907 } // AugmentedSubmittables1908} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts104.0 KiBsourcehistory