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<<<<<<< HEAD12import type { AccountId32, Call, H160, H256, MultiAddress, Permill } from '@polkadot/types/interfaces/runtime';13=======14<<<<<<< HEAD15import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';16>>>>>>> chore: regenerate types17import 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';18=======19import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill, Weight } from '@polkadot/types/interfaces/runtime';20<<<<<<< HEAD21import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';22=======23import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumTransactionTransactionV2, OrmlVestingVestingSchedule, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';24>>>>>>> chore: regenerate types25>>>>>>> chore: regenerate types2627export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;28export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;29export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;3031declare module '@polkadot/api-base/types/submittable' {32 interface AugmentedSubmittables<ApiType extends ApiTypes> {33 appPromotion: {34 /**35 * Recalculates interest for the specified number of stakers.36 * If all stakers are not recalculated, the next call of the extrinsic37 * will continue the recalculation, from those stakers for whom this38 * was not perform in last call.39 * 40 * # Permissions41 * 42 * * Pallet admin43 * 44 * # Arguments45 * 46 * * `stakers_number`: the number of stakers for which recalculation will be performed47 **/48 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;49 /**50 * Sets an address as the the admin.51 * 52 * # Permissions53 * 54 * * Sudo55 * 56 * # Arguments57 * 58 * * `admin`: account of the new admin.59 **/60 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;61 /**62 * Sets the pallet to be the sponsor for the collection.63 * 64 * # Permissions65 * 66 * * Pallet admin67 * 68 * # Arguments69 * 70 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`71 **/72 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;73 /**74 * Sets the pallet to be the sponsor for the contract.75 * 76 * # Permissions77 * 78 * * Pallet admin79 * 80 * # Arguments81 * 82 * * `contract_id`: the contract address that will be sponsored by `pallet_id`83 **/84 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;85 /**86 * Stakes the amount of native tokens.87 * Sets `amount` to the locked state.88 * The maximum number of stakes for a staker is 10.89 * 90 * # Arguments91 * 92 * * `amount`: in native tokens.93 **/94 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;95 /**96 * Removes the pallet as the sponsor for the collection.97 * Returns [`NoPermission`][`Error::NoPermission`]98 * if the pallet wasn't the sponsor.99 * 100 * # Permissions101 * 102 * * Pallet admin103 * 104 * # Arguments105 * 106 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`107 **/108 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;109 /**110 * Removes the pallet as the sponsor for the contract.111 * Returns [`NoPermission`][`Error::NoPermission`]112 * if the pallet wasn't the sponsor.113 * 114 * # Permissions115 * 116 * * Pallet admin117 * 118 * # Arguments119 * 120 * * `contract_id`: the contract address that is sponsored by `pallet_id`121 **/122 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;123 /**124 * Unstakes all stakes.125 * Moves the sum of all stakes to the `reserved` state.126 * After the end of `PendingInterval` this sum becomes completely127 * free for further use.128 **/129 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;130 /**131 * Generic tx132 **/133 [key: string]: SubmittableExtrinsicFunction<ApiType>;134 };135 balances: {136 /**137 * Exactly as `transfer`, except the origin must be root and the source account may be138 * specified.139 * # <weight>140 * - Same as transfer, but additional read and write because the source account is not141 * assumed to be in the overlay.142 * # </weight>143 **/144 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>]>;145 /**146 * Unreserve some balance from a user by force.147 * 148 * Can only be called by ROOT.149 **/150 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;151 /**152 * Set the balances of a given account.153 * 154 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will155 * also alter the total issuance of the system (`TotalIssuance`) appropriately.156 * If the new free or reserved balance is below the existential deposit,157 * it will reset the account nonce (`frame_system::AccountNonce`).158 * 159 * The dispatch origin for this call is `root`.160 **/161 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>]>;162 /**163 * Transfer some liquid free balance to another account.164 * 165 * `transfer` will set the `FreeBalance` of the sender and receiver.166 * If the sender's account is below the existential deposit as a result167 * of the transfer, the account will be reaped.168 * 169 * The dispatch origin for this call must be `Signed` by the transactor.170 * 171 * # <weight>172 * - Dependent on arguments but not critical, given proper implementations for input config173 * types. See related functions below.174 * - It contains a limited number of reads and writes internally and no complex175 * computation.176 * 177 * Related functions:178 * 179 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.180 * - Transferring balances to accounts that did not exist before will cause181 * `T::OnNewAccount::on_new_account` to be called.182 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.183 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check184 * that the transfer will not kill the origin account.185 * ---------------------------------186 * - Origin account is already in memory, so no DB operations for them.187 * # </weight>188 **/189 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>]>;190 /**191 * Transfer the entire transferable balance from the caller account.192 * 193 * NOTE: This function only attempts to transfer _transferable_ balances. This means that194 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be195 * transferred by this function. To ensure that this function results in a killed account,196 * you might need to prepare the account by removing any reference counters, storage197 * deposits, etc...198 * 199 * The dispatch origin of this call must be Signed.200 * 201 * - `dest`: The recipient of the transfer.202 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all203 * of the funds the account has, causing the sender account to be killed (false), or204 * transfer everything except at least the existential deposit, which will guarantee to205 * keep the sender account alive (true). # <weight>206 * - O(1). Just like transfer, but reading the user's transferable balance first.207 * #</weight>208 **/209 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;210 /**211 * Same as the [`transfer`] call, but with a check that the transfer will not kill the212 * origin account.213 * 214 * 99% of the time you want [`transfer`] instead.215 * 216 * [`transfer`]: struct.Pallet.html#method.transfer217 **/218 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>]>;219 /**220 * Generic tx221 **/222 [key: string]: SubmittableExtrinsicFunction<ApiType>;223 };224 charging: {225 /**226 * Generic tx227 **/228 [key: string]: SubmittableExtrinsicFunction<ApiType>;229 };230 configuration: {231 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;232 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;233 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;234 setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;235 /**236 * Generic tx237 **/238 [key: string]: SubmittableExtrinsicFunction<ApiType>;239 };240 cumulusXcm: {241 /**242 * Generic tx243 **/244 [key: string]: SubmittableExtrinsicFunction<ApiType>;245 };246 dmpQueue: {247 /**248 * Service a single overweight message.249 * 250 * - `origin`: Must pass `ExecuteOverweightOrigin`.251 * - `index`: The index of the overweight message to service.252 * - `weight_limit`: The amount of weight that message execution may take.253 * 254 * Errors:255 * - `Unknown`: Message of `index` is unknown.256 * - `OverLimit`: Message execution may use greater than `weight_limit`.257 * 258 * Events:259 * - `OverweightServiced`: On success.260 **/261 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;262 /**263 * Generic tx264 **/265 [key: string]: SubmittableExtrinsicFunction<ApiType>;266 };267 ethereum: {268 /**269 * Transact an Ethereum transaction.270 **/271 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;272 /**273 * Generic tx274 **/275 [key: string]: SubmittableExtrinsicFunction<ApiType>;276 };277 evm: {278 /**279 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.280 **/281 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>]>>]>;282 /**283 * Issue an EVM create operation. This is similar to a contract creation transaction in284 * Ethereum.285 **/286 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>]>>]>;287 /**288 * Issue an EVM create2 operation.289 **/290 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>]>>]>;291 /**292 * Withdraw balance from EVM into currency/balances pallet.293 **/294 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;295 /**296 * Generic tx297 **/298 [key: string]: SubmittableExtrinsicFunction<ApiType>;299 };300 evmMigration: {301 /**302 * Start contract migration, inserts contract stub at target address,303 * and marks account as pending, allowing to insert storage304 **/305 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;306 /**307 * Finish contract migration, allows it to be called.308 * It is not possible to alter contract storage via [`Self::set_data`]309 * after this call.310 **/311 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;312 /**313 * Create ethereum events attached to the fake transaction314 **/315 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;316 /**317 * Create substrate events318 **/319 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;320 /**321 * Insert items into contract storage, this method can be called322 * multiple times323 **/324 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;325 /**326 * Generic tx327 **/328 [key: string]: SubmittableExtrinsicFunction<ApiType>;329 };330 foreignAssets: {331 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]>;332 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]>;333 /**334 * Generic tx335 **/336 [key: string]: SubmittableExtrinsicFunction<ApiType>;337 };338 inflation: {339 /**340 * This method sets the inflation start date. Can be only called once.341 * Inflation start block can be backdated and will catch up. The method will create Treasury342 * account if it does not exist and perform the first inflation deposit.343 * 344 * # Permissions345 * 346 * * Root347 * 348 * # Arguments349 * 350 * * inflation_start_relay_block: The relay chain block at which inflation should start351 **/352 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;353 /**354 * Generic tx355 **/356 [key: string]: SubmittableExtrinsicFunction<ApiType>;357 };358 maintenance: {359 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;360 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;361 /**362 * Generic tx363 **/364 [key: string]: SubmittableExtrinsicFunction<ApiType>;365 };366 parachainSystem: {367 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;368 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;369 /**370 * Set the current validation data.371 * 372 * This should be invoked exactly once per block. It will panic at the finalization373 * phase if the call was not invoked.374 * 375 * The dispatch origin for this call must be `Inherent`376 * 377 * As a side effect, this function upgrades the current validation function378 * if the appropriate time has come.379 **/380 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;381 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;382 /**383 * Generic tx384 **/385 [key: string]: SubmittableExtrinsicFunction<ApiType>;386 };387 polkadotXcm: {388 /**389 * Execute an XCM message from a local, signed, origin.390 * 391 * An event is deposited indicating whether `msg` could be executed completely or only392 * partially.393 * 394 * No more than `max_weight` will be used in its attempted execution. If this is less than the395 * maximum amount of weight that the message could take to be executed, then no execution396 * attempt will be made.397 * 398 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully399 * to completion; only that *some* of it was executed.400 **/401 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;402 /**403 * Set a safe XCM version (the version that XCM should be encoded with if the most recent404 * version a destination can accept is unknown).405 * 406 * - `origin`: Must be Root.407 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.408 **/409 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;410 /**411 * Ask a location to notify us regarding their XCM version and any changes to it.412 * 413 * - `origin`: Must be Root.414 * - `location`: The location to which we should subscribe for XCM version notifications.415 **/416 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;417 /**418 * Require that a particular destination should no longer notify us regarding any XCM419 * version changes.420 * 421 * - `origin`: Must be Root.422 * - `location`: The location to which we are currently subscribed for XCM version423 * notifications which we no longer desire.424 **/425 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;426 /**427 * Extoll that a particular destination can be communicated with through a particular428 * version of XCM.429 * 430 * - `origin`: Must be Root.431 * - `location`: The destination that is being described.432 * - `xcm_version`: The latest version of XCM that `location` supports.433 **/434 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;435 /**436 * Transfer some assets from the local chain to the sovereign account of a destination437 * chain and forward a notification XCM.438 * 439 * Fee payment on the destination side is made from the asset in the `assets` vector of440 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight441 * is needed than `weight_limit`, then the operation will fail and the assets send may be442 * at risk.443 * 444 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.445 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send446 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.447 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be448 * an `AccountId32` value.449 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the450 * `dest` side.451 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay452 * fees.453 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.454 **/455 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]>;456 /**457 * Teleport some assets from the local chain to some destination chain.458 * 459 * Fee payment on the destination side is made from the asset in the `assets` vector of460 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight461 * is needed than `weight_limit`, then the operation will fail and the assets send may be462 * at risk.463 * 464 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.465 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send466 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.467 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be468 * an `AccountId32` value.469 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the470 * `dest` side. May not be empty.471 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay472 * fees.473 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.474 **/475 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]>;476 /**477 * Transfer some assets from the local chain to the sovereign account of a destination478 * chain and forward a notification XCM.479 * 480 * Fee payment on the destination side is made from the asset in the `assets` vector of481 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,482 * with all fees taken as needed from the asset.483 * 484 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.485 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send486 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.487 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be488 * an `AccountId32` value.489 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the490 * `dest` side.491 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay492 * fees.493 **/494 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]>;495 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;496 /**497 * Teleport some assets from the local chain to some destination chain.498 * 499 * Fee payment on the destination side is made from the asset in the `assets` vector of500 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,501 * with all fees taken as needed from the asset.502 * 503 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.504 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send505 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.506 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be507 * an `AccountId32` value.508 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the509 * `dest` side. May not be empty.510 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay511 * fees.512 **/513 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]>;514 /**515 * Generic tx516 **/517 [key: string]: SubmittableExtrinsicFunction<ApiType>;518 };519 rmrkCore: {520 /**521 * Accept an NFT sent from another account to self or an owned NFT.522 * 523 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.524 * 525 * # Permissions:526 * - Token-owner-to-be527 * 528 * # Arguments:529 * - `origin`: sender of the transaction530 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.531 * - `rmrk_nft_id`: ID of the NFT to be accepted.532 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,533 * whichever the accepted NFT was sent to.534 **/535 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;536 /**537 * Accept the addition of a newly created pending resource to an existing NFT.538 * 539 * This transaction is needed when a resource is created and assigned to an NFT540 * by a non-owner, i.e. the collection issuer, with one of the541 * [`add_...` transactions](Pallet::add_basic_resource).542 * 543 * # Permissions:544 * - Token owner545 * 546 * # Arguments:547 * - `origin`: sender of the transaction548 * - `rmrk_collection_id`: RMRK collection ID of the NFT.549 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.550 * - `resource_id`: ID of the newly created pending resource.551 * accept the addition of a new resource to an existing NFT552 **/553 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;554 /**555 * Accept the removal of a removal-pending resource from an NFT.556 * 557 * This transaction is needed when a non-owner, i.e. the collection issuer,558 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.559 * 560 * # Permissions:561 * - Token owner562 * 563 * # Arguments:564 * - `origin`: sender of the transaction565 * - `rmrk_collection_id`: RMRK collection ID of the NFT.566 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.567 * - `resource_id`: ID of the removal-pending resource.568 **/569 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;570 /**571 * Create and set/propose a basic resource for an NFT.572 * 573 * A basic resource is the simplest, lacking a Base and anything that comes with it.574 * See RMRK docs for more information and examples.575 * 576 * # Permissions:577 * - Collection issuer - if not the token owner, adding the resource will warrant578 * the owner's [acceptance](Pallet::accept_resource).579 * 580 * # Arguments:581 * - `origin`: sender of the transaction582 * - `rmrk_collection_id`: RMRK collection ID of the NFT.583 * - `nft_id`: ID of the NFT to assign a resource to.584 * - `resource`: Data of the resource to be created.585 **/586 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]>;587 /**588 * Create and set/propose a composable resource for an NFT.589 * 590 * A composable resource links to a Base and has a subset of its Parts it is composed of.591 * See RMRK docs for more information and examples.592 * 593 * # Permissions:594 * - Collection issuer - if not the token owner, adding the resource will warrant595 * the owner's [acceptance](Pallet::accept_resource).596 * 597 * # Arguments:598 * - `origin`: sender of the transaction599 * - `rmrk_collection_id`: RMRK collection ID of the NFT.600 * - `nft_id`: ID of the NFT to assign a resource to.601 * - `resource`: Data of the resource to be created.602 **/603 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]>;604 /**605 * Create and set/propose a slot resource for an NFT.606 * 607 * A slot resource links to a Base and a slot ID in it which it can fit into.608 * See RMRK docs for more information and examples.609 * 610 * # Permissions:611 * - Collection issuer - if not the token owner, adding the resource will warrant612 * the owner's [acceptance](Pallet::accept_resource).613 * 614 * # Arguments:615 * - `origin`: sender of the transaction616 * - `rmrk_collection_id`: RMRK collection ID of the NFT.617 * - `nft_id`: ID of the NFT to assign a resource to.618 * - `resource`: Data of the resource to be created.619 **/620 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]>;621 /**622 * Burn an NFT, destroying it and its nested tokens up to the specified limit.623 * If the burning budget is exceeded, the transaction is reverted.624 * 625 * This is the way to burn a nested token as well.626 * 627 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).628 * 629 * # Permissions:630 * * Token owner631 * 632 * # Arguments:633 * - `origin`: sender of the transaction634 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.635 * - `nft_id`: ID of the NFT to be destroyed.636 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction637 * is reverted if there are more tokens to burn in the nesting tree than this number.638 * This is primarily a mechanism of transaction weight control.639 **/640 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;641 /**642 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).643 * 644 * # Permissions:645 * * Collection issuer646 * 647 * # Arguments:648 * - `origin`: sender of the transaction649 * - `collection_id`: RMRK collection ID to change the issuer of.650 * - `new_issuer`: Collection's new issuer.651 **/652 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;653 /**654 * Create a new collection of NFTs.655 * 656 * # Permissions:657 * * Anyone - will be assigned as the issuer of the collection.658 * 659 * # Arguments:660 * - `origin`: sender of the transaction661 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.662 * - `max`: Optional maximum number of tokens.663 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.664 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.665 **/666 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;667 /**668 * Destroy a collection.669 * 670 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.671 * 672 * # Permissions:673 * * Collection issuer674 * 675 * # Arguments:676 * - `origin`: sender of the transaction677 * - `collection_id`: RMRK ID of the collection to destroy.678 **/679 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;680 /**681 * "Lock" the collection and prevent new token creation. Cannot be undone.682 * 683 * # Permissions:684 * * Collection issuer685 * 686 * # Arguments:687 * - `origin`: sender of the transaction688 * - `collection_id`: RMRK ID of the collection to lock.689 **/690 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;691 /**692 * Mint an NFT in a specified collection.693 * 694 * # Permissions:695 * * Collection issuer696 * 697 * # Arguments:698 * - `origin`: sender of the transaction699 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).700 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.701 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.702 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.703 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.704 * - `transferable`: Can this NFT be transferred? Cannot be changed.705 * - `resources`: Resource data to be added to the NFT immediately after minting.706 **/707 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>>]>;708 /**709 * Reject an NFT sent from another account to self or owned NFT.710 * The NFT in question will not be sent back and burnt instead.711 * 712 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.713 * 714 * # Permissions:715 * - Token-owner-to-be-not716 * 717 * # Arguments:718 * - `origin`: sender of the transaction719 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.720 * - `rmrk_nft_id`: ID of the NFT to be rejected.721 **/722 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;723 /**724 * Remove and erase a resource from an NFT.725 * 726 * If the sender does not own the NFT, then it will be pending confirmation,727 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.728 * 729 * # Permissions730 * - Collection issuer731 * 732 * # Arguments733 * - `origin`: sender of the transaction734 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.735 * - `nft_id`: ID of the NFT with a resource to be removed.736 * - `resource_id`: ID of the resource to be removed.737 **/738 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;739 /**740 * Transfer an NFT from an account/NFT A to another account/NFT B.741 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].742 * 743 * If the target owner is an NFT owned by another account, then the NFT will enter744 * the pending state and will have to be accepted by the other account.745 * 746 * # Permissions:747 * - Token owner748 * 749 * # Arguments:750 * - `origin`: sender of the transaction751 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.752 * - `rmrk_nft_id`: ID of the NFT to be transferred.753 * - `new_owner`: New owner of the nft which can be either an account or a NFT.754 **/755 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;756 /**757 * Set a different order of resource priorities for an NFT. Priorities can be used,758 * for example, for order of rendering.759 * 760 * Note that the priorities are not updated automatically, and are an empty vector761 * by default. There is no pre-set definition for the order to be particular,762 * it can be interpreted arbitrarily use-case by use-case.763 * 764 * # Permissions:765 * - Token owner766 * 767 * # Arguments:768 * - `origin`: sender of the transaction769 * - `rmrk_collection_id`: RMRK collection ID of the NFT.770 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.771 * - `priorities`: Ordered vector of resource IDs.772 **/773 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;774 /**775 * Add or edit a custom user property, a key-value pair, describing the metadata776 * of a token or a collection, on either one of these.777 * 778 * Note that in this proxy implementation many details regarding RMRK are stored779 * as scoped properties prefixed with "rmrk:", normally inaccessible780 * to external transactions and RPCs.781 * 782 * # Permissions:783 * - Collection issuer - in case of collection property784 * - Token owner - in case of NFT property785 * 786 * # Arguments:787 * - `origin`: sender of the transaction788 * - `rmrk_collection_id`: RMRK collection ID.789 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.790 * - `key`: Key of the custom property to be referenced by.791 * - `value`: Value of the custom property to be stored.792 **/793 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]>;794 /**795 * Generic tx796 **/797 [key: string]: SubmittableExtrinsicFunction<ApiType>;798 };799 rmrkEquip: {800 /**801 * Create a new Base.802 * 803 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)804 * 805 * # Permissions806 * - Anyone - will be assigned as the issuer of the Base.807 * 808 * # Arguments:809 * - `origin`: Caller, will be assigned as the issuer of the Base810 * - `base_type`: Arbitrary media type, e.g. "svg".811 * - `symbol`: Arbitrary client-chosen symbol.812 * - `parts`: Array of Fixed and Slot Parts composing the Base,813 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).814 **/815 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>]>;816 /**817 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.818 * 819 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).820 * 821 * # Permissions:822 * - Base issuer823 * 824 * # Arguments:825 * - `origin`: sender of the transaction826 * - `base_id`: Base containing the Slot Part to be updated.827 * - `slot_id`: Slot Part whose Equippable List is being updated .828 * - `equippables`: List of equippables that will override the current Equippables list.829 **/830 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]>;831 /**832 * Add a Theme to a Base.833 * A Theme named "default" is required prior to adding other Themes.834 * 835 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).836 * 837 * # Permissions:838 * - Base issuer839 * 840 * # Arguments:841 * - `origin`: sender of the transaction842 * - `base_id`: Base ID containing the Theme to be updated.843 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an844 * array of [key, value, inherit].845 * - `key`: Arbitrary BoundedString, defined by client.846 * - `value`: Arbitrary BoundedString, defined by client.847 * - `inherit`: Optional bool.848 **/849 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;850 /**851 * Generic tx852 **/853 [key: string]: SubmittableExtrinsicFunction<ApiType>;854 };855 structure: {856 /**857 * Generic tx858 **/859 [key: string]: SubmittableExtrinsicFunction<ApiType>;860 };861 sudo: {862 /**863 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo864 * key.865 * 866 * The dispatch origin for this call must be _Signed_.867 * 868 * # <weight>869 * - O(1).870 * - Limited storage reads.871 * - One DB change.872 * # </weight>873 **/874 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;875 /**876 * Authenticates the sudo key and dispatches a function call with `Root` origin.877 * 878 * The dispatch origin for this call must be _Signed_.879 * 880 * # <weight>881 * - O(1).882 * - Limited storage reads.883 * - One DB write (event).884 * - Weight of derivative `call` execution + 10,000.885 * # </weight>886 **/887 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;888 /**889 * Authenticates the sudo key and dispatches a function call with `Signed` origin from890 * a given account.891 * 892 * The dispatch origin for this call must be _Signed_.893 * 894 * # <weight>895 * - O(1).896 * - Limited storage reads.897 * - One DB write (event).898 * - Weight of derivative `call` execution + 10,000.899 * # </weight>900 **/901 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]>;902 /**903 * Authenticates the sudo key and dispatches a function call with `Root` origin.904 * This function does not check the weight of the call, and instead allows the905 * Sudo user to specify the weight of the call.906 * 907 * The dispatch origin for this call must be _Signed_.908 * 909 * # <weight>910 * - O(1).911 * - The weight of this call is defined by the caller.912 * # </weight>913 **/914 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;915 /**916 * Generic tx917 **/918 [key: string]: SubmittableExtrinsicFunction<ApiType>;919 };920 system: {921 /**922 * Kill all storage items with a key that starts with the given prefix.923 * 924 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under925 * the prefix we are removing to accurately calculate the weight of this function.926 **/927 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;928 /**929 * Kill some items from storage.930 **/931 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;932 /**933 * Make some on-chain remark.934 * 935 * # <weight>936 * - `O(1)`937 * # </weight>938 **/939 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;940 /**941 * Make some on-chain remark and emit event.942 **/943 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;944 /**945 * Set the new runtime code.946 * 947 * # <weight>948 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`949 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is950 * expensive).951 * - 1 storage write (codec `O(C)`).952 * - 1 digest item.953 * - 1 event.954 * The weight of this function is dependent on the runtime, but generally this is very955 * expensive. We will treat this as a full block.956 * # </weight>957 **/958 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;959 /**960 * Set the new runtime code without doing any checks of the given `code`.961 * 962 * # <weight>963 * - `O(C)` where `C` length of `code`964 * - 1 storage write (codec `O(C)`).965 * - 1 digest item.966 * - 1 event.967 * The weight of this function is dependent on the runtime. We will treat this as a full968 * block. # </weight>969 **/970 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;971 /**972 * Set the number of pages in the WebAssembly environment's heap.973 **/974 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;975 /**976 * Set some items of storage.977 **/978 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;979 /**980 * Generic tx981 **/982 [key: string]: SubmittableExtrinsicFunction<ApiType>;983 };984 testUtils: {985 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;986 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;987 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;988 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;989 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;990 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;991 /**992 * Generic tx993 **/994 [key: string]: SubmittableExtrinsicFunction<ApiType>;995 };996 timestamp: {997 /**998 * Set the current time.999 * 1000 * This call should be invoked exactly once per block. It will panic at the finalization1001 * phase, if this call hasn't been invoked by that time.1002 * 1003 * The timestamp should be greater than the previous one by the amount specified by1004 * `MinimumPeriod`.1005 * 1006 * The dispatch origin for this call must be `Inherent`.1007 * 1008 * # <weight>1009 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1010 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1011 * `on_finalize`)1012 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1013 * # </weight>1014 **/1015 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1016 /**1017 * Generic tx1018 **/1019 [key: string]: SubmittableExtrinsicFunction<ApiType>;1020 };1021 tokens: {1022 /**1023 * Exactly as `transfer`, except the origin must be root and the source1024 * account may be specified.1025 * 1026 * The dispatch origin for this call must be _Root_.1027 * 1028 * - `source`: The sender of the transfer.1029 * - `dest`: The recipient of the transfer.1030 * - `currency_id`: currency type.1031 * - `amount`: free balance amount to tranfer.1032 **/1033 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>]>;1034 /**1035 * Set the balances of a given account.1036 * 1037 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1038 * will also decrease the total issuance of the system1039 * (`TotalIssuance`). If the new free or reserved balance is below the1040 * existential deposit, it will reap the `AccountInfo`.1041 * 1042 * The dispatch origin for this call is `root`.1043 **/1044 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>]>;1045 /**1046 * Transfer some liquid free balance to another account.1047 * 1048 * `transfer` will set the `FreeBalance` of the sender and receiver.1049 * It will decrease the total issuance of the system by the1050 * `TransferFee`. If the sender's account is below the existential1051 * deposit as a result of the transfer, the account will be reaped.1052 * 1053 * The dispatch origin for this call must be `Signed` by the1054 * transactor.1055 * 1056 * - `dest`: The recipient of the transfer.1057 * - `currency_id`: currency type.1058 * - `amount`: free balance amount to tranfer.1059 **/1060 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>]>;1061 /**1062 * Transfer all remaining balance to the given account.1063 * 1064 * NOTE: This function only attempts to transfer _transferable_1065 * balances. This means that any locked, reserved, or existential1066 * deposits (when `keep_alive` is `true`), will not be transferred by1067 * this function. To ensure that this function results in a killed1068 * account, you might need to prepare the account by removing any1069 * reference counters, storage deposits, etc...1070 * 1071 * The dispatch origin for this call must be `Signed` by the1072 * transactor.1073 * 1074 * - `dest`: The recipient of the transfer.1075 * - `currency_id`: currency type.1076 * - `keep_alive`: A boolean to determine if the `transfer_all`1077 * operation should send all of the funds the account has, causing1078 * the sender account to be killed (false), or transfer everything1079 * except at least the existential deposit, which will guarantee to1080 * keep the sender account alive (true).1081 **/1082 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]>;1083 /**1084 * Same as the [`transfer`] call, but with a check that the transfer1085 * will not kill the origin account.1086 * 1087 * 99% of the time you want [`transfer`] instead.1088 * 1089 * The dispatch origin for this call must be `Signed` by the1090 * transactor.1091 * 1092 * - `dest`: The recipient of the transfer.1093 * - `currency_id`: currency type.1094 * - `amount`: free balance amount to tranfer.1095 **/1096 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>]>;1097 /**1098 * Generic tx1099 **/1100 [key: string]: SubmittableExtrinsicFunction<ApiType>;1101 };1102 treasury: {1103 /**1104 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1105 * and the original deposit will be returned.1106 * 1107 * May only be called from `T::ApproveOrigin`.1108 * 1109 * # <weight>1110 * - Complexity: O(1).1111 * - DbReads: `Proposals`, `Approvals`1112 * - DbWrite: `Approvals`1113 * # </weight>1114 **/1115 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1116 /**1117 * Put forward a suggestion for spending. A deposit proportional to the value1118 * is reserved and slashed if the proposal is rejected. It is returned once the1119 * proposal is awarded.1120 * 1121 * # <weight>1122 * - Complexity: O(1)1123 * - DbReads: `ProposalCount`, `origin account`1124 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1125 * # </weight>1126 **/1127 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]>;1128 /**1129 * Reject a proposed spend. The original deposit will be slashed.1130 * 1131 * May only be called from `T::RejectOrigin`.1132 * 1133 * # <weight>1134 * - Complexity: O(1)1135 * - DbReads: `Proposals`, `rejected proposer account`1136 * - DbWrites: `Proposals`, `rejected proposer account`1137 * # </weight>1138 **/1139 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1140 /**1141 * Force a previously approved proposal to be removed from the approval queue.1142 * The original deposit will no longer be returned.1143 * 1144 * May only be called from `T::RejectOrigin`.1145 * - `proposal_id`: The index of a proposal1146 * 1147 * # <weight>1148 * - Complexity: O(A) where `A` is the number of approvals1149 * - Db reads and writes: `Approvals`1150 * # </weight>1151 * 1152 * Errors:1153 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1154 * i.e., the proposal has not been approved. This could also mean the proposal does not1155 * exist altogether, thus there is no way it would have been approved in the first place.1156 **/1157 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1158 /**1159 * Propose and approve a spend of treasury funds.1160 * 1161 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1162 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1163 * - `beneficiary`: The destination account for the transfer.1164 * 1165 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1166 * beneficiary.1167 **/1168 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]>;1169 /**1170 * Generic tx1171 **/1172 [key: string]: SubmittableExtrinsicFunction<ApiType>;1173 };1174 unique: {1175 /**1176 * Add an admin to a collection.1177 * 1178 * NFT Collection can be controlled by multiple admin addresses1179 * (some which can also be servers, for example). Admins can issue1180 * and burn NFTs, as well as add and remove other admins,1181 * but cannot change NFT or Collection ownership.1182 * 1183 * # Permissions1184 * 1185 * * Collection owner1186 * * Collection admin1187 * 1188 * # Arguments1189 * 1190 * * `collection_id`: ID of the Collection to add an admin for.1191 * * `new_admin`: Address of new admin to add.1192 **/1193 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1194 /**1195 * Add an address to allow list.1196 * 1197 * # Permissions1198 * 1199 * * Collection owner1200 * * Collection admin1201 * 1202 * # Arguments1203 * 1204 * * `collection_id`: ID of the modified collection.1205 * * `address`: ID of the address to be added to the allowlist.1206 **/1207 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1208 /**1209 * Allow a non-permissioned address to transfer or burn an item.1210 * 1211 * # Permissions1212 * 1213 * * Collection owner1214 * * Collection admin1215 * * Current item owner1216 * 1217 * # Arguments1218 * 1219 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1220 * * `collection_id`: ID of the collection the item belongs to.1221 * * `item_id`: ID of the item transactions on which are now approved.1222 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1223 * Set to 0 to revoke the approval.1224 **/1225 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]>;1226 /**1227 * Destroy a token on behalf of the owner as a non-owner account.1228 * 1229 * See also: [`approve`][`Pallet::approve`].1230 * 1231 * After this method executes, one approval is removed from the total so that1232 * the approved address will not be able to transfer this item again from this owner.1233 * 1234 * # Permissions1235 * 1236 * * Collection owner1237 * * Collection admin1238 * * Current token owner1239 * * Address approved by current item owner1240 * 1241 * # Arguments1242 * 1243 * * `from`: The owner of the burning item.1244 * * `collection_id`: ID of the collection to which the item belongs.1245 * * `item_id`: ID of item to burn.1246 * * `value`: Number of pieces to burn.1247 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1248 * * Fungible Mode: The desired number of pieces to burn.1249 * * Re-Fungible Mode: The desired number of pieces to burn.1250 **/1251 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]>;1252 /**1253 * Destroy an item.1254 * 1255 * # Permissions1256 * 1257 * * Collection owner1258 * * Collection admin1259 * * Current item owner1260 * 1261 * # Arguments1262 * 1263 * * `collection_id`: ID of the collection to which the item belongs.1264 * * `item_id`: ID of item to burn.1265 * * `value`: Number of pieces of the item to destroy.1266 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1267 * * Fungible Mode: The desired number of pieces to burn.1268 * * Re-Fungible Mode: The desired number of pieces to burn.1269 **/1270 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1271 /**1272 * Change the owner of the collection.1273 * 1274 * # Permissions1275 * 1276 * * Collection owner1277 * 1278 * # Arguments1279 * 1280 * * `collection_id`: ID of the modified collection.1281 * * `new_owner`: ID of the account that will become the owner.1282 **/1283 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1284 /**1285 * Confirm own sponsorship of a collection, becoming the sponsor.1286 * 1287 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1288 * Sponsor can pay the fees of a transaction instead of the sender,1289 * but only within specified limits.1290 * 1291 * # Permissions1292 * 1293 * * Sponsor-to-be1294 * 1295 * # Arguments1296 * 1297 * * `collection_id`: ID of the collection with the pending sponsor.1298 **/1299 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1300 /**1301 * Create a collection of tokens.1302 * 1303 * Each Token may have multiple properties encoded as an array of bytes1304 * of certain length. The initial owner of the collection is set1305 * to the address that signed the transaction and can be changed later.1306 * 1307 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1308 * 1309 * # Permissions1310 * 1311 * * Anyone - becomes the owner of the new collection.1312 * 1313 * # Arguments1314 * 1315 * * `collection_name`: Wide-character string with collection name1316 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1317 * * `collection_description`: Wide-character string with collection description1318 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1319 * * `token_prefix`: Byte string containing the token prefix to mark a collection1320 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1321 * * `mode`: Type of items stored in the collection and type dependent data.1322 **/1323 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]>;1324 /**1325 * Create a collection with explicit parameters.1326 * 1327 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1328 * 1329 * # Permissions1330 * 1331 * * Anyone - becomes the owner of the new collection.1332 * 1333 * # Arguments1334 * 1335 * * `data`: Explicit data of a collection used for its creation.1336 **/1337 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]>;1338 /**1339 * Mint an item within a collection.1340 * 1341 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1342 * 1343 * # Permissions1344 * 1345 * * Collection owner1346 * * Collection admin1347 * * Anyone if1348 * * Allow List is enabled, and1349 * * Address is added to allow list, and1350 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1351 * 1352 * # Arguments1353 * 1354 * * `collection_id`: ID of the collection to which an item would belong.1355 * * `owner`: Address of the initial owner of the item.1356 * * `data`: Token data describing the item to store on chain.1357 **/1358 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]>;1359 /**1360 * Create multiple items within a collection.1361 * 1362 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1363 * 1364 * # Permissions1365 * 1366 * * Collection owner1367 * * Collection admin1368 * * Anyone if1369 * * Allow List is enabled, and1370 * * Address is added to the allow list, and1371 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1372 * 1373 * # Arguments1374 * 1375 * * `collection_id`: ID of the collection to which the tokens would belong.1376 * * `owner`: Address of the initial owner of the tokens.1377 * * `items_data`: Vector of data describing each item to be created.1378 **/1379 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>]>;1380 /**1381 * Create multiple items within a collection with explicitly specified initial parameters.1382 * 1383 * # Permissions1384 * 1385 * * Collection owner1386 * * Collection admin1387 * * Anyone if1388 * * Allow List is enabled, and1389 * * Address is added to allow list, and1390 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1391 * 1392 * # Arguments1393 * 1394 * * `collection_id`: ID of the collection to which the tokens would belong.1395 * * `data`: Explicit item creation data.1396 **/1397 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1398 /**1399 * Delete specified collection properties.1400 * 1401 * # Permissions1402 * 1403 * * Collection Owner1404 * * Collection Admin1405 * 1406 * # Arguments1407 * 1408 * * `collection_id`: ID of the modified collection.1409 * * `property_keys`: Vector of keys of the properties to be deleted.1410 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1411 **/1412 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1413 /**1414 * Delete specified token properties. Currently properties only work with NFTs.1415 * 1416 * # Permissions1417 * 1418 * * Depends on collection's token property permissions and specified property mutability:1419 * * Collection owner1420 * * Collection admin1421 * * Token owner1422 * 1423 * # Arguments1424 * 1425 * * `collection_id`: ID of the collection to which the token belongs.1426 * * `token_id`: ID of the modified token.1427 * * `property_keys`: Vector of keys of the properties to be deleted.1428 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1429 **/1430 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1431 /**1432 * Destroy a collection if no tokens exist within.1433 * 1434 * # Permissions1435 * 1436 * * Collection owner1437 * 1438 * # Arguments1439 * 1440 * * `collection_id`: Collection to destroy.1441 **/1442 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1443 /**1444 * Repairs a collection if the data was somehow corrupted.1445 * 1446 * # Arguments1447 * 1448 * * `collection_id`: ID of the collection to repair.1449 **/1450 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1451 /**1452 * Repairs a token if the data was somehow corrupted.1453 * 1454 * # Arguments1455 * 1456 * * `collection_id`: ID of the collection the item belongs to.1457 * * `item_id`: ID of the item.1458 **/1459 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1460 /**1461 * Remove admin of a collection.1462 * 1463 * An admin address can remove itself. List of admins may become empty,1464 * in which case only Collection Owner will be able to add an Admin.1465 * 1466 * # Permissions1467 * 1468 * * Collection owner1469 * * Collection admin1470 * 1471 * # Arguments1472 * 1473 * * `collection_id`: ID of the collection to remove the admin for.1474 * * `account_id`: Address of the admin to remove.1475 **/1476 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1477 /**1478 * Remove a collection's a sponsor, making everyone pay for their own transactions.1479 * 1480 * # Permissions1481 * 1482 * * Collection owner1483 * 1484 * # Arguments1485 * 1486 * * `collection_id`: ID of the collection with the sponsor to remove.1487 **/1488 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1489 /**1490 * Remove an address from allow list.1491 * 1492 * # Permissions1493 * 1494 * * Collection owner1495 * * Collection admin1496 * 1497 * # Arguments1498 * 1499 * * `collection_id`: ID of the modified collection.1500 * * `address`: ID of the address to be removed from the allowlist.1501 **/1502 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1503 /**1504 * Re-partition a refungible token, while owning all of its parts/pieces.1505 * 1506 * # Permissions1507 * 1508 * * Token owner (must own every part)1509 * 1510 * # Arguments1511 * 1512 * * `collection_id`: ID of the collection the RFT belongs to.1513 * * `token_id`: ID of the RFT.1514 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1515 **/1516 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1517 /**1518 * Sets or unsets the approval of a given operator.1519 * 1520 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1521 * 1522 * # Arguments1523 * 1524 * * `owner`: Token owner1525 * * `operator`: Operator1526 * * `approve`: Should operator status be granted or revoked?1527 **/1528 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1529 /**1530 * Set specific limits of a collection. Empty, or None fields mean chain default.1531 * 1532 * # Permissions1533 * 1534 * * Collection owner1535 * * Collection admin1536 * 1537 * # Arguments1538 * 1539 * * `collection_id`: ID of the modified collection.1540 * * `new_limit`: New limits of the collection. Fields that are not set (None)1541 * will not overwrite the old ones.1542 **/1543 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]>;1544 /**1545 * Set specific permissions of a collection. Empty, or None fields mean chain default.1546 * 1547 * # Permissions1548 * 1549 * * Collection owner1550 * * Collection admin1551 * 1552 * # Arguments1553 * 1554 * * `collection_id`: ID of the modified collection.1555 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1556 * will not overwrite the old ones.1557 **/1558 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1559 /**1560 * Add or change collection properties.1561 * 1562 * # Permissions1563 * 1564 * * Collection owner1565 * * Collection admin1566 * 1567 * # Arguments1568 * 1569 * * `collection_id`: ID of the modified collection.1570 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1571 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1572 **/1573 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1574 /**1575 * Set (invite) a new collection sponsor.1576 * 1577 * If successful, confirmation from the sponsor-to-be will be pending.1578 * 1579 * # Permissions1580 * 1581 * * Collection owner1582 * * Collection admin1583 * 1584 * # Arguments1585 * 1586 * * `collection_id`: ID of the modified collection.1587 * * `new_sponsor`: ID of the account of the sponsor-to-be.1588 **/1589 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1590 /**1591 * Add or change token properties according to collection's permissions.1592 * Currently properties only work with NFTs.1593 * 1594 * # Permissions1595 * 1596 * * Depends on collection's token property permissions and specified property mutability:1597 * * Collection owner1598 * * Collection admin1599 * * Token owner1600 * 1601 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1602 * 1603 * # Arguments1604 * 1605 * * `collection_id: ID of the collection to which the token belongs.1606 * * `token_id`: ID of the modified token.1607 * * `properties`: Vector of key-value pairs stored as the token's metadata.1608 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1609 **/1610 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>]>;1611 /**1612 * Add or change token property permissions of a collection.1613 * 1614 * Without a permission for a particular key, a property with that key1615 * cannot be created in a token.1616 * 1617 * # Permissions1618 * 1619 * * Collection owner1620 * * Collection admin1621 * 1622 * # Arguments1623 * 1624 * * `collection_id`: ID of the modified collection.1625 * * `property_permissions`: Vector of permissions for property keys.1626 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1627 **/1628 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1629 /**1630 * Completely allow or disallow transfers for a particular collection.1631 * 1632 * # Permissions1633 * 1634 * * Collection owner1635 * 1636 * # Arguments1637 * 1638 * * `collection_id`: ID of the collection.1639 * * `value`: New value of the flag, are transfers allowed?1640 **/1641 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1642 /**1643 * Change ownership of the token.1644 * 1645 * # Permissions1646 * 1647 * * Collection owner1648 * * Collection admin1649 * * Current token owner1650 * 1651 * # Arguments1652 * 1653 * * `recipient`: Address of token recipient.1654 * * `collection_id`: ID of the collection the item belongs to.1655 * * `item_id`: ID of the item.1656 * * Non-Fungible Mode: Required.1657 * * Fungible Mode: Ignored.1658 * * Re-Fungible Mode: Required.1659 * 1660 * * `value`: Amount to transfer.1661 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1662 * * Fungible Mode: The desired number of pieces to transfer.1663 * * Re-Fungible Mode: The desired number of pieces to transfer.1664 **/1665 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]>;1666 /**1667 * Change ownership of an item on behalf of the owner as a non-owner account.1668 * 1669 * See the [`approve`][`Pallet::approve`] method for additional information.1670 * 1671 * After this method executes, one approval is removed from the total so that1672 * the approved address will not be able to transfer this item again from this owner.1673 * 1674 * # Permissions1675 * 1676 * * Collection owner1677 * * Collection admin1678 * * Current item owner1679 * * Address approved by current item owner1680 * 1681 * # Arguments1682 * 1683 * * `from`: Address that currently owns the token.1684 * * `recipient`: Address of the new token-owner-to-be.1685 * * `collection_id`: ID of the collection the item.1686 * * `item_id`: ID of the item to be transferred.1687 * * `value`: Amount to transfer.1688 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1689 * * Fungible Mode: The desired number of pieces to transfer.1690 * * Re-Fungible Mode: The desired number of pieces to transfer.1691 **/1692 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]>;1693 /**1694 * Generic tx1695 **/1696 [key: string]: SubmittableExtrinsicFunction<ApiType>;1697 };1698 vesting: {1699 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1700 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1701 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>]>;1702 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]>;1703 /**1704 * Generic tx1705 **/1706 [key: string]: SubmittableExtrinsicFunction<ApiType>;1707 };1708 xcmpQueue: {1709 /**1710 * Resumes all XCM executions for the XCMP queue.1711 * 1712 * Note that this function doesn't change the status of the in/out bound channels.1713 * 1714 * - `origin`: Must pass `ControllerOrigin`.1715 **/1716 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1717 /**1718 * Services a single overweight XCM.1719 * 1720 * - `origin`: Must pass `ExecuteOverweightOrigin`.1721 * - `index`: The index of the overweight XCM to service1722 * - `weight_limit`: The amount of weight that XCM execution may take.1723 * 1724 * Errors:1725 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1726 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1727 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1728 * 1729 * Events:1730 * - `OverweightServiced`: On success.1731 **/1732 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1733 /**1734 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1735 * 1736 * - `origin`: Must pass `ControllerOrigin`.1737 **/1738 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1739 /**1740 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1741 * messages from the channel.1742 * 1743 * - `origin`: Must pass `Root`.1744 * - `new`: Desired value for `QueueConfigData.drop_threshold`1745 **/1746 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1747 /**1748 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1749 * message sending may recommence after it has been suspended.1750 * 1751 * - `origin`: Must pass `Root`.1752 * - `new`: Desired value for `QueueConfigData.resume_threshold`1753 **/1754 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1755 /**1756 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1757 * suspend their sending.1758 * 1759 * - `origin`: Must pass `Root`.1760 * - `new`: Desired value for `QueueConfigData.suspend_value`1761 **/1762 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1763 /**1764 * Overwrites the amount of remaining weight under which we stop processing messages.1765 * 1766 * - `origin`: Must pass `Root`.1767 * - `new`: Desired value for `QueueConfigData.threshold_weight`1768 **/1769 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1770 /**1771 * Overwrites the speed to which the available weight approaches the maximum weight.1772 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1773 * 1774 * - `origin`: Must pass `Root`.1775 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1776 **/1777 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1778 /**1779 * Overwrite the maximum amount of weight any individual message may consume.1780 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1781 * 1782 * - `origin`: Must pass `Root`.1783 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1784 **/1785 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1786 /**1787 * Generic tx1788 **/1789 [key: string]: SubmittableExtrinsicFunction<ApiType>;1790 };1791 xTokens: {1792 /**1793 * Transfer native currencies.1794 * 1795 * `dest_weight_limit` is the weight for XCM execution on the dest1796 * chain, and it would be charged from the transferred assets. If set1797 * below requirements, the execution may fail and assets wouldn't be1798 * received.1799 * 1800 * It's a no-op if any error on local XCM execution or message sending.1801 * Note sending assets out per se doesn't guarantee they would be1802 * received. Receiving depends on if the XCM message could be delivered1803 * by the network, and if the receiving chain would handle1804 * messages correctly.1805 **/1806 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]>;1807 /**1808 * Transfer `MultiAsset`.1809 * 1810 * `dest_weight_limit` is the weight for XCM execution on the dest1811 * chain, and it would be charged from the transferred assets. If set1812 * below requirements, the execution may fail and assets wouldn't be1813 * received.1814 * 1815 * It's a no-op if any error on local XCM execution or message sending.1816 * Note sending assets out per se doesn't guarantee they would be1817 * received. Receiving depends on if the XCM message could be delivered1818 * by the network, and if the receiving chain would handle1819 * messages correctly.1820 **/1821 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]>;1822 /**1823 * Transfer several `MultiAsset` specifying the item to be used as fee1824 * 1825 * `dest_weight_limit` is the weight for XCM execution on the dest1826 * chain, and it would be charged from the transferred assets. If set1827 * below requirements, the execution may fail and assets wouldn't be1828 * received.1829 * 1830 * `fee_item` is index of the MultiAssets that we want to use for1831 * payment1832 * 1833 * It's a no-op if any error on local XCM execution or message sending.1834 * Note sending assets out per se doesn't guarantee they would be1835 * received. Receiving depends on if the XCM message could be delivered1836 * by the network, and if the receiving chain would handle1837 * messages correctly.1838 **/1839 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]>;1840 /**1841 * Transfer `MultiAsset` specifying the fee and amount as separate.1842 * 1843 * `dest_weight_limit` is the weight for XCM execution on the dest1844 * chain, and it would be charged from the transferred assets. If set1845 * below requirements, the execution may fail and assets wouldn't be1846 * received.1847 * 1848 * `fee` is the multiasset to be spent to pay for execution in1849 * destination chain. Both fee and amount will be subtracted form the1850 * callers balance For now we only accept fee and asset having the same1851 * `MultiLocation` id.1852 * 1853 * If `fee` is not high enough to cover for the execution costs in the1854 * destination chain, then the assets will be trapped in the1855 * destination chain1856 * 1857 * It's a no-op if any error on local XCM execution or message sending.1858 * Note sending assets out per se doesn't guarantee they would be1859 * received. Receiving depends on if the XCM message could be delivered1860 * by the network, and if the receiving chain would handle1861 * messages correctly.1862 **/1863 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]>;1864 /**1865 * Transfer several currencies specifying the item to be used as fee1866 * 1867 * `dest_weight_limit` is the weight for XCM execution on the dest1868 * chain, and it would be charged from the transferred assets. If set1869 * below requirements, the execution may fail and assets wouldn't be1870 * received.1871 * 1872 * `fee_item` is index of the currencies tuple that we want to use for1873 * payment1874 * 1875 * It's a no-op if any error on local XCM execution or message sending.1876 * Note sending assets out per se doesn't guarantee they would be1877 * received. Receiving depends on if the XCM message could be delivered1878 * by the network, and if the receiving chain would handle1879 * messages correctly.1880 **/1881 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]>;1882 /**1883 * Transfer native currencies specifying the fee and amount as1884 * separate.1885 * 1886 * `dest_weight_limit` is the weight for XCM execution on the dest1887 * chain, and it would be charged from the transferred assets. If set1888 * below requirements, the execution may fail and assets wouldn't be1889 * received.1890 * 1891 * `fee` is the amount to be spent to pay for execution in destination1892 * chain. Both fee and amount will be subtracted form the callers1893 * balance.1894 * 1895 * If `fee` is not high enough to cover for the execution costs in the1896 * destination chain, then the assets will be trapped in the1897 * destination chain1898 * 1899 * It's a no-op if any error on local XCM execution or message sending.1900 * Note sending assets out per se doesn't guarantee they would be1901 * received. Receiving depends on if the XCM message could be delivered1902 * by the network, and if the receiving chain would handle1903 * messages correctly.1904 **/1905 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]>;1906 /**1907 * Generic tx1908 **/1909 [key: string]: SubmittableExtrinsicFunction<ApiType>;1910 };1911 } // AugmentedSubmittables1912} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts105.9 KiBsourcehistory