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';20import 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';21<<<<<<< HEAD22=======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 types26=======27>>>>>>> fix: regenerate types after rebase2829export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;30export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;31export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;3233declare module '@polkadot/api-base/types/submittable' {34 interface AugmentedSubmittables<ApiType extends ApiTypes> {35 appPromotion: {36 /**37 * Recalculates interest for the specified number of stakers.38 * If all stakers are not recalculated, the next call of the extrinsic39 * will continue the recalculation, from those stakers for whom this40 * was not perform in last call.41 * 42 * # Permissions43 * 44 * * Pallet admin45 * 46 * # Arguments47 * 48 * * `stakers_number`: the number of stakers for which recalculation will be performed49 **/50 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;51 /**52 * Sets an address as the the admin.53 * 54 * # Permissions55 * 56 * * Sudo57 * 58 * # Arguments59 * 60 * * `admin`: account of the new admin.61 **/62 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;63 /**64 * Sets the pallet to be the sponsor for the collection.65 * 66 * # Permissions67 * 68 * * Pallet admin69 * 70 * # Arguments71 * 72 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`73 **/74 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;75 /**76 * Sets the pallet to be the sponsor for the contract.77 * 78 * # Permissions79 * 80 * * Pallet admin81 * 82 * # Arguments83 * 84 * * `contract_id`: the contract address that will be sponsored by `pallet_id`85 **/86 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;87 /**88 * Stakes the amount of native tokens.89 * Sets `amount` to the locked state.90 * The maximum number of stakes for a staker is 10.91 * 92 * # Arguments93 * 94 * * `amount`: in native tokens.95 **/96 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;97 /**98 * Removes the pallet as the sponsor for the collection.99 * Returns [`NoPermission`][`Error::NoPermission`]100 * if the pallet wasn't the sponsor.101 * 102 * # Permissions103 * 104 * * Pallet admin105 * 106 * # Arguments107 * 108 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`109 **/110 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;111 /**112 * Removes the pallet as the sponsor for the contract.113 * Returns [`NoPermission`][`Error::NoPermission`]114 * if the pallet wasn't the sponsor.115 * 116 * # Permissions117 * 118 * * Pallet admin119 * 120 * # Arguments121 * 122 * * `contract_id`: the contract address that is sponsored by `pallet_id`123 **/124 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;125 /**126 * Unstakes all stakes.127 * Moves the sum of all stakes to the `reserved` state.128 * After the end of `PendingInterval` this sum becomes completely129 * free for further use.130 **/131 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;132 /**133 * Generic tx134 **/135 [key: string]: SubmittableExtrinsicFunction<ApiType>;136 };137 balances: {138 /**139 * Exactly as `transfer`, except the origin must be root and the source account may be140 * specified.141 * # <weight>142 * - Same as transfer, but additional read and write because the source account is not143 * assumed to be in the overlay.144 * # </weight>145 **/146 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>]>;147 /**148 * Unreserve some balance from a user by force.149 * 150 * Can only be called by ROOT.151 **/152 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;153 /**154 * Set the balances of a given account.155 * 156 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will157 * also alter the total issuance of the system (`TotalIssuance`) appropriately.158 * If the new free or reserved balance is below the existential deposit,159 * it will reset the account nonce (`frame_system::AccountNonce`).160 * 161 * The dispatch origin for this call is `root`.162 **/163 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>]>;164 /**165 * Transfer some liquid free balance to another account.166 * 167 * `transfer` will set the `FreeBalance` of the sender and receiver.168 * If the sender's account is below the existential deposit as a result169 * of the transfer, the account will be reaped.170 * 171 * The dispatch origin for this call must be `Signed` by the transactor.172 * 173 * # <weight>174 * - Dependent on arguments but not critical, given proper implementations for input config175 * types. See related functions below.176 * - It contains a limited number of reads and writes internally and no complex177 * computation.178 * 179 * Related functions:180 * 181 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.182 * - Transferring balances to accounts that did not exist before will cause183 * `T::OnNewAccount::on_new_account` to be called.184 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.185 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check186 * that the transfer will not kill the origin account.187 * ---------------------------------188 * - Origin account is already in memory, so no DB operations for them.189 * # </weight>190 **/191 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>]>;192 /**193 * Transfer the entire transferable balance from the caller account.194 * 195 * NOTE: This function only attempts to transfer _transferable_ balances. This means that196 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be197 * transferred by this function. To ensure that this function results in a killed account,198 * you might need to prepare the account by removing any reference counters, storage199 * deposits, etc...200 * 201 * The dispatch origin of this call must be Signed.202 * 203 * - `dest`: The recipient of the transfer.204 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all205 * of the funds the account has, causing the sender account to be killed (false), or206 * transfer everything except at least the existential deposit, which will guarantee to207 * keep the sender account alive (true). # <weight>208 * - O(1). Just like transfer, but reading the user's transferable balance first.209 * #</weight>210 **/211 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;212 /**213 * Same as the [`transfer`] call, but with a check that the transfer will not kill the214 * origin account.215 * 216 * 99% of the time you want [`transfer`] instead.217 * 218 * [`transfer`]: struct.Pallet.html#method.transfer219 **/220 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>]>;221 /**222 * Generic tx223 **/224 [key: string]: SubmittableExtrinsicFunction<ApiType>;225 };226 charging: {227 /**228 * Generic tx229 **/230 [key: string]: SubmittableExtrinsicFunction<ApiType>;231 };232 configuration: {233 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;234 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;235 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;236 setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;237 /**238 * Generic tx239 **/240 [key: string]: SubmittableExtrinsicFunction<ApiType>;241 };242 cumulusXcm: {243 /**244 * Generic tx245 **/246 [key: string]: SubmittableExtrinsicFunction<ApiType>;247 };248 dmpQueue: {249 /**250 * Service a single overweight message.251 * 252 * - `origin`: Must pass `ExecuteOverweightOrigin`.253 * - `index`: The index of the overweight message to service.254 * - `weight_limit`: The amount of weight that message execution may take.255 * 256 * Errors:257 * - `Unknown`: Message of `index` is unknown.258 * - `OverLimit`: Message execution may use greater than `weight_limit`.259 * 260 * Events:261 * - `OverweightServiced`: On success.262 **/263 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;264 /**265 * Generic tx266 **/267 [key: string]: SubmittableExtrinsicFunction<ApiType>;268 };269 ethereum: {270 /**271 * Transact an Ethereum transaction.272 **/273 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;274 /**275 * Generic tx276 **/277 [key: string]: SubmittableExtrinsicFunction<ApiType>;278 };279 evm: {280 /**281 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.282 **/283 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>]>>]>;284 /**285 * Issue an EVM create operation. This is similar to a contract creation transaction in286 * Ethereum.287 **/288 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>]>>]>;289 /**290 * Issue an EVM create2 operation.291 **/292 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>]>>]>;293 /**294 * Withdraw balance from EVM into currency/balances pallet.295 **/296 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;297 /**298 * Generic tx299 **/300 [key: string]: SubmittableExtrinsicFunction<ApiType>;301 };302 evmMigration: {303 /**304 * Start contract migration, inserts contract stub at target address,305 * and marks account as pending, allowing to insert storage306 **/307 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;308 /**309 * Finish contract migration, allows it to be called.310 * It is not possible to alter contract storage via [`Self::set_data`]311 * after this call.312 **/313 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;314 /**315 * Create ethereum events attached to the fake transaction316 **/317 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;318 /**319 * Create substrate events320 **/321 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;322 /**323 * Insert items into contract storage, this method can be called324 * multiple times325 **/326 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;327 /**328 * Generic tx329 **/330 [key: string]: SubmittableExtrinsicFunction<ApiType>;331 };332 foreignAssets: {333 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]>;334 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]>;335 /**336 * Generic tx337 **/338 [key: string]: SubmittableExtrinsicFunction<ApiType>;339 };340 inflation: {341 /**342 * This method sets the inflation start date. Can be only called once.343 * Inflation start block can be backdated and will catch up. The method will create Treasury344 * account if it does not exist and perform the first inflation deposit.345 * 346 * # Permissions347 * 348 * * Root349 * 350 * # Arguments351 * 352 * * inflation_start_relay_block: The relay chain block at which inflation should start353 **/354 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;355 /**356 * Generic tx357 **/358 [key: string]: SubmittableExtrinsicFunction<ApiType>;359 };360 maintenance: {361 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;362 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;363 /**364 * Generic tx365 **/366 [key: string]: SubmittableExtrinsicFunction<ApiType>;367 };368 parachainSystem: {369 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;370 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;371 /**372 * Set the current validation data.373 * 374 * This should be invoked exactly once per block. It will panic at the finalization375 * phase if the call was not invoked.376 * 377 * The dispatch origin for this call must be `Inherent`378 * 379 * As a side effect, this function upgrades the current validation function380 * if the appropriate time has come.381 **/382 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;383 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;384 /**385 * Generic tx386 **/387 [key: string]: SubmittableExtrinsicFunction<ApiType>;388 };389 polkadotXcm: {390 /**391 * Execute an XCM message from a local, signed, origin.392 * 393 * An event is deposited indicating whether `msg` could be executed completely or only394 * partially.395 * 396 * No more than `max_weight` will be used in its attempted execution. If this is less than the397 * maximum amount of weight that the message could take to be executed, then no execution398 * attempt will be made.399 * 400 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully401 * to completion; only that *some* of it was executed.402 **/403 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;404 /**405 * Set a safe XCM version (the version that XCM should be encoded with if the most recent406 * version a destination can accept is unknown).407 * 408 * - `origin`: Must be Root.409 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.410 **/411 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;412 /**413 * Ask a location to notify us regarding their XCM version and any changes to it.414 * 415 * - `origin`: Must be Root.416 * - `location`: The location to which we should subscribe for XCM version notifications.417 **/418 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;419 /**420 * Require that a particular destination should no longer notify us regarding any XCM421 * version changes.422 * 423 * - `origin`: Must be Root.424 * - `location`: The location to which we are currently subscribed for XCM version425 * notifications which we no longer desire.426 **/427 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;428 /**429 * Extoll that a particular destination can be communicated with through a particular430 * version of XCM.431 * 432 * - `origin`: Must be Root.433 * - `location`: The destination that is being described.434 * - `xcm_version`: The latest version of XCM that `location` supports.435 **/436 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;437 /**438 * Transfer some assets from the local chain to the sovereign account of a destination439 * chain and forward a notification XCM.440 * 441 * Fee payment on the destination side is made from the asset in the `assets` vector of442 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight443 * is needed than `weight_limit`, then the operation will fail and the assets send may be444 * at risk.445 * 446 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.447 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send448 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.449 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be450 * an `AccountId32` value.451 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the452 * `dest` side.453 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay454 * fees.455 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.456 **/457 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]>;458 /**459 * Teleport some assets from the local chain to some destination chain.460 * 461 * Fee payment on the destination side is made from the asset in the `assets` vector of462 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight463 * is needed than `weight_limit`, then the operation will fail and the assets send may be464 * at risk.465 * 466 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.467 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send468 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.469 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be470 * an `AccountId32` value.471 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the472 * `dest` side. May not be empty.473 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay474 * fees.475 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.476 **/477 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]>;478 /**479 * Transfer some assets from the local chain to the sovereign account of a destination480 * chain and forward a notification XCM.481 * 482 * Fee payment on the destination side is made from the asset in the `assets` vector of483 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,484 * with all fees taken as needed from the asset.485 * 486 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.487 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send488 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.489 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be490 * an `AccountId32` value.491 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the492 * `dest` side.493 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay494 * fees.495 **/496 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]>;497 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;498 /**499 * Teleport some assets from the local chain to some destination chain.500 * 501 * Fee payment on the destination side is made from the asset in the `assets` vector of502 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,503 * with all fees taken as needed from the asset.504 * 505 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.506 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send507 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.508 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be509 * an `AccountId32` value.510 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the511 * `dest` side. May not be empty.512 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay513 * fees.514 **/515 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]>;516 /**517 * Generic tx518 **/519 [key: string]: SubmittableExtrinsicFunction<ApiType>;520 };521 rmrkCore: {522 /**523 * Accept an NFT sent from another account to self or an owned NFT.524 * 525 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.526 * 527 * # Permissions:528 * - Token-owner-to-be529 * 530 * # Arguments:531 * - `origin`: sender of the transaction532 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.533 * - `rmrk_nft_id`: ID of the NFT to be accepted.534 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,535 * whichever the accepted NFT was sent to.536 **/537 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;538 /**539 * Accept the addition of a newly created pending resource to an existing NFT.540 * 541 * This transaction is needed when a resource is created and assigned to an NFT542 * by a non-owner, i.e. the collection issuer, with one of the543 * [`add_...` transactions](Pallet::add_basic_resource).544 * 545 * # Permissions:546 * - Token owner547 * 548 * # Arguments:549 * - `origin`: sender of the transaction550 * - `rmrk_collection_id`: RMRK collection ID of the NFT.551 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.552 * - `resource_id`: ID of the newly created pending resource.553 * accept the addition of a new resource to an existing NFT554 **/555 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;556 /**557 * Accept the removal of a removal-pending resource from an NFT.558 * 559 * This transaction is needed when a non-owner, i.e. the collection issuer,560 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.561 * 562 * # Permissions:563 * - Token owner564 * 565 * # Arguments:566 * - `origin`: sender of the transaction567 * - `rmrk_collection_id`: RMRK collection ID of the NFT.568 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.569 * - `resource_id`: ID of the removal-pending resource.570 **/571 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;572 /**573 * Create and set/propose a basic resource for an NFT.574 * 575 * A basic resource is the simplest, lacking a Base and anything that comes with it.576 * See RMRK docs for more information and examples.577 * 578 * # Permissions:579 * - Collection issuer - if not the token owner, adding the resource will warrant580 * the owner's [acceptance](Pallet::accept_resource).581 * 582 * # Arguments:583 * - `origin`: sender of the transaction584 * - `rmrk_collection_id`: RMRK collection ID of the NFT.585 * - `nft_id`: ID of the NFT to assign a resource to.586 * - `resource`: Data of the resource to be created.587 **/588 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]>;589 /**590 * Create and set/propose a composable resource for an NFT.591 * 592 * A composable resource links to a Base and has a subset of its Parts it is composed of.593 * See RMRK docs for more information and examples.594 * 595 * # Permissions:596 * - Collection issuer - if not the token owner, adding the resource will warrant597 * the owner's [acceptance](Pallet::accept_resource).598 * 599 * # Arguments:600 * - `origin`: sender of the transaction601 * - `rmrk_collection_id`: RMRK collection ID of the NFT.602 * - `nft_id`: ID of the NFT to assign a resource to.603 * - `resource`: Data of the resource to be created.604 **/605 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]>;606 /**607 * Create and set/propose a slot resource for an NFT.608 * 609 * A slot resource links to a Base and a slot ID in it which it can fit into.610 * See RMRK docs for more information and examples.611 * 612 * # Permissions:613 * - Collection issuer - if not the token owner, adding the resource will warrant614 * the owner's [acceptance](Pallet::accept_resource).615 * 616 * # Arguments:617 * - `origin`: sender of the transaction618 * - `rmrk_collection_id`: RMRK collection ID of the NFT.619 * - `nft_id`: ID of the NFT to assign a resource to.620 * - `resource`: Data of the resource to be created.621 **/622 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]>;623 /**624 * Burn an NFT, destroying it and its nested tokens up to the specified limit.625 * If the burning budget is exceeded, the transaction is reverted.626 * 627 * This is the way to burn a nested token as well.628 * 629 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).630 * 631 * # Permissions:632 * * Token owner633 * 634 * # Arguments:635 * - `origin`: sender of the transaction636 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.637 * - `nft_id`: ID of the NFT to be destroyed.638 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction639 * is reverted if there are more tokens to burn in the nesting tree than this number.640 * This is primarily a mechanism of transaction weight control.641 **/642 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;643 /**644 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).645 * 646 * # Permissions:647 * * Collection issuer648 * 649 * # Arguments:650 * - `origin`: sender of the transaction651 * - `collection_id`: RMRK collection ID to change the issuer of.652 * - `new_issuer`: Collection's new issuer.653 **/654 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;655 /**656 * Create a new collection of NFTs.657 * 658 * # Permissions:659 * * Anyone - will be assigned as the issuer of the collection.660 * 661 * # Arguments:662 * - `origin`: sender of the transaction663 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.664 * - `max`: Optional maximum number of tokens.665 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.666 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.667 **/668 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;669 /**670 * Destroy a collection.671 * 672 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.673 * 674 * # Permissions:675 * * Collection issuer676 * 677 * # Arguments:678 * - `origin`: sender of the transaction679 * - `collection_id`: RMRK ID of the collection to destroy.680 **/681 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;682 /**683 * "Lock" the collection and prevent new token creation. Cannot be undone.684 * 685 * # Permissions:686 * * Collection issuer687 * 688 * # Arguments:689 * - `origin`: sender of the transaction690 * - `collection_id`: RMRK ID of the collection to lock.691 **/692 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;693 /**694 * Mint an NFT in a specified collection.695 * 696 * # Permissions:697 * * Collection issuer698 * 699 * # Arguments:700 * - `origin`: sender of the transaction701 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).702 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.703 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.704 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.705 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.706 * - `transferable`: Can this NFT be transferred? Cannot be changed.707 * - `resources`: Resource data to be added to the NFT immediately after minting.708 **/709 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>>]>;710 /**711 * Reject an NFT sent from another account to self or owned NFT.712 * The NFT in question will not be sent back and burnt instead.713 * 714 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.715 * 716 * # Permissions:717 * - Token-owner-to-be-not718 * 719 * # Arguments:720 * - `origin`: sender of the transaction721 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.722 * - `rmrk_nft_id`: ID of the NFT to be rejected.723 **/724 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;725 /**726 * Remove and erase a resource from an NFT.727 * 728 * If the sender does not own the NFT, then it will be pending confirmation,729 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.730 * 731 * # Permissions732 * - Collection issuer733 * 734 * # Arguments735 * - `origin`: sender of the transaction736 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.737 * - `nft_id`: ID of the NFT with a resource to be removed.738 * - `resource_id`: ID of the resource to be removed.739 **/740 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;741 /**742 * Transfer an NFT from an account/NFT A to another account/NFT B.743 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].744 * 745 * If the target owner is an NFT owned by another account, then the NFT will enter746 * the pending state and will have to be accepted by the other account.747 * 748 * # Permissions:749 * - Token owner750 * 751 * # Arguments:752 * - `origin`: sender of the transaction753 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.754 * - `rmrk_nft_id`: ID of the NFT to be transferred.755 * - `new_owner`: New owner of the nft which can be either an account or a NFT.756 **/757 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;758 /**759 * Set a different order of resource priorities for an NFT. Priorities can be used,760 * for example, for order of rendering.761 * 762 * Note that the priorities are not updated automatically, and are an empty vector763 * by default. There is no pre-set definition for the order to be particular,764 * it can be interpreted arbitrarily use-case by use-case.765 * 766 * # Permissions:767 * - Token owner768 * 769 * # Arguments:770 * - `origin`: sender of the transaction771 * - `rmrk_collection_id`: RMRK collection ID of the NFT.772 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.773 * - `priorities`: Ordered vector of resource IDs.774 **/775 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;776 /**777 * Add or edit a custom user property, a key-value pair, describing the metadata778 * of a token or a collection, on either one of these.779 * 780 * Note that in this proxy implementation many details regarding RMRK are stored781 * as scoped properties prefixed with "rmrk:", normally inaccessible782 * to external transactions and RPCs.783 * 784 * # Permissions:785 * - Collection issuer - in case of collection property786 * - Token owner - in case of NFT property787 * 788 * # Arguments:789 * - `origin`: sender of the transaction790 * - `rmrk_collection_id`: RMRK collection ID.791 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.792 * - `key`: Key of the custom property to be referenced by.793 * - `value`: Value of the custom property to be stored.794 **/795 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]>;796 /**797 * Generic tx798 **/799 [key: string]: SubmittableExtrinsicFunction<ApiType>;800 };801 rmrkEquip: {802 /**803 * Create a new Base.804 * 805 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)806 * 807 * # Permissions808 * - Anyone - will be assigned as the issuer of the Base.809 * 810 * # Arguments:811 * - `origin`: Caller, will be assigned as the issuer of the Base812 * - `base_type`: Arbitrary media type, e.g. "svg".813 * - `symbol`: Arbitrary client-chosen symbol.814 * - `parts`: Array of Fixed and Slot Parts composing the Base,815 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).816 **/817 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>]>;818 /**819 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.820 * 821 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).822 * 823 * # Permissions:824 * - Base issuer825 * 826 * # Arguments:827 * - `origin`: sender of the transaction828 * - `base_id`: Base containing the Slot Part to be updated.829 * - `slot_id`: Slot Part whose Equippable List is being updated .830 * - `equippables`: List of equippables that will override the current Equippables list.831 **/832 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]>;833 /**834 * Add a Theme to a Base.835 * A Theme named "default" is required prior to adding other Themes.836 * 837 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).838 * 839 * # Permissions:840 * - Base issuer841 * 842 * # Arguments:843 * - `origin`: sender of the transaction844 * - `base_id`: Base ID containing the Theme to be updated.845 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an846 * array of [key, value, inherit].847 * - `key`: Arbitrary BoundedString, defined by client.848 * - `value`: Arbitrary BoundedString, defined by client.849 * - `inherit`: Optional bool.850 **/851 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;852 /**853 * Generic tx854 **/855 [key: string]: SubmittableExtrinsicFunction<ApiType>;856 };857 structure: {858 /**859 * Generic tx860 **/861 [key: string]: SubmittableExtrinsicFunction<ApiType>;862 };863 sudo: {864 /**865 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo866 * key.867 * 868 * The dispatch origin for this call must be _Signed_.869 * 870 * # <weight>871 * - O(1).872 * - Limited storage reads.873 * - One DB change.874 * # </weight>875 **/876 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;877 /**878 * Authenticates the sudo key and dispatches a function call with `Root` origin.879 * 880 * The dispatch origin for this call must be _Signed_.881 * 882 * # <weight>883 * - O(1).884 * - Limited storage reads.885 * - One DB write (event).886 * - Weight of derivative `call` execution + 10,000.887 * # </weight>888 **/889 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;890 /**891 * Authenticates the sudo key and dispatches a function call with `Signed` origin from892 * a given account.893 * 894 * The dispatch origin for this call must be _Signed_.895 * 896 * # <weight>897 * - O(1).898 * - Limited storage reads.899 * - One DB write (event).900 * - Weight of derivative `call` execution + 10,000.901 * # </weight>902 **/903 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]>;904 /**905 * Authenticates the sudo key and dispatches a function call with `Root` origin.906 * This function does not check the weight of the call, and instead allows the907 * Sudo user to specify the weight of the call.908 * 909 * The dispatch origin for this call must be _Signed_.910 * 911 * # <weight>912 * - O(1).913 * - The weight of this call is defined by the caller.914 * # </weight>915 **/916 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;917 /**918 * Generic tx919 **/920 [key: string]: SubmittableExtrinsicFunction<ApiType>;921 };922 system: {923 /**924 * Kill all storage items with a key that starts with the given prefix.925 * 926 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under927 * the prefix we are removing to accurately calculate the weight of this function.928 **/929 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;930 /**931 * Kill some items from storage.932 **/933 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;934 /**935 * Make some on-chain remark.936 * 937 * # <weight>938 * - `O(1)`939 * # </weight>940 **/941 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;942 /**943 * Make some on-chain remark and emit event.944 **/945 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;946 /**947 * Set the new runtime code.948 * 949 * # <weight>950 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`951 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is952 * expensive).953 * - 1 storage write (codec `O(C)`).954 * - 1 digest item.955 * - 1 event.956 * The weight of this function is dependent on the runtime, but generally this is very957 * expensive. We will treat this as a full block.958 * # </weight>959 **/960 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;961 /**962 * Set the new runtime code without doing any checks of the given `code`.963 * 964 * # <weight>965 * - `O(C)` where `C` length of `code`966 * - 1 storage write (codec `O(C)`).967 * - 1 digest item.968 * - 1 event.969 * The weight of this function is dependent on the runtime. We will treat this as a full970 * block. # </weight>971 **/972 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;973 /**974 * Set the number of pages in the WebAssembly environment's heap.975 **/976 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;977 /**978 * Set some items of storage.979 **/980 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;981 /**982 * Generic tx983 **/984 [key: string]: SubmittableExtrinsicFunction<ApiType>;985 };986 testUtils: {987 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;988 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;989 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;990 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;991 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;992 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;993 /**994 * Generic tx995 **/996 [key: string]: SubmittableExtrinsicFunction<ApiType>;997 };998 timestamp: {999 /**1000 * Set the current time.1001 * 1002 * This call should be invoked exactly once per block. It will panic at the finalization1003 * phase, if this call hasn't been invoked by that time.1004 * 1005 * The timestamp should be greater than the previous one by the amount specified by1006 * `MinimumPeriod`.1007 * 1008 * The dispatch origin for this call must be `Inherent`.1009 * 1010 * # <weight>1011 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1012 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1013 * `on_finalize`)1014 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1015 * # </weight>1016 **/1017 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1018 /**1019 * Generic tx1020 **/1021 [key: string]: SubmittableExtrinsicFunction<ApiType>;1022 };1023 tokens: {1024 /**1025 * Exactly as `transfer`, except the origin must be root and the source1026 * account may be specified.1027 * 1028 * The dispatch origin for this call must be _Root_.1029 * 1030 * - `source`: The sender of the transfer.1031 * - `dest`: The recipient of the transfer.1032 * - `currency_id`: currency type.1033 * - `amount`: free balance amount to tranfer.1034 **/1035 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>]>;1036 /**1037 * Set the balances of a given account.1038 * 1039 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1040 * will also decrease the total issuance of the system1041 * (`TotalIssuance`). If the new free or reserved balance is below the1042 * existential deposit, it will reap the `AccountInfo`.1043 * 1044 * The dispatch origin for this call is `root`.1045 **/1046 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>]>;1047 /**1048 * Transfer some liquid free balance to another account.1049 * 1050 * `transfer` will set the `FreeBalance` of the sender and receiver.1051 * It will decrease the total issuance of the system by the1052 * `TransferFee`. If the sender's account is below the existential1053 * deposit as a result of the transfer, the account will be reaped.1054 * 1055 * The dispatch origin for this call must be `Signed` by the1056 * transactor.1057 * 1058 * - `dest`: The recipient of the transfer.1059 * - `currency_id`: currency type.1060 * - `amount`: free balance amount to tranfer.1061 **/1062 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>]>;1063 /**1064 * Transfer all remaining balance to the given account.1065 * 1066 * NOTE: This function only attempts to transfer _transferable_1067 * balances. This means that any locked, reserved, or existential1068 * deposits (when `keep_alive` is `true`), will not be transferred by1069 * this function. To ensure that this function results in a killed1070 * account, you might need to prepare the account by removing any1071 * reference counters, storage deposits, etc...1072 * 1073 * The dispatch origin for this call must be `Signed` by the1074 * transactor.1075 * 1076 * - `dest`: The recipient of the transfer.1077 * - `currency_id`: currency type.1078 * - `keep_alive`: A boolean to determine if the `transfer_all`1079 * operation should send all of the funds the account has, causing1080 * the sender account to be killed (false), or transfer everything1081 * except at least the existential deposit, which will guarantee to1082 * keep the sender account alive (true).1083 **/1084 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]>;1085 /**1086 * Same as the [`transfer`] call, but with a check that the transfer1087 * will not kill the origin account.1088 * 1089 * 99% of the time you want [`transfer`] instead.1090 * 1091 * The dispatch origin for this call must be `Signed` by the1092 * transactor.1093 * 1094 * - `dest`: The recipient of the transfer.1095 * - `currency_id`: currency type.1096 * - `amount`: free balance amount to tranfer.1097 **/1098 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>]>;1099 /**1100 * Generic tx1101 **/1102 [key: string]: SubmittableExtrinsicFunction<ApiType>;1103 };1104 treasury: {1105 /**1106 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1107 * and the original deposit will be returned.1108 * 1109 * May only be called from `T::ApproveOrigin`.1110 * 1111 * # <weight>1112 * - Complexity: O(1).1113 * - DbReads: `Proposals`, `Approvals`1114 * - DbWrite: `Approvals`1115 * # </weight>1116 **/1117 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1118 /**1119 * Put forward a suggestion for spending. A deposit proportional to the value1120 * is reserved and slashed if the proposal is rejected. It is returned once the1121 * proposal is awarded.1122 * 1123 * # <weight>1124 * - Complexity: O(1)1125 * - DbReads: `ProposalCount`, `origin account`1126 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1127 * # </weight>1128 **/1129 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]>;1130 /**1131 * Reject a proposed spend. The original deposit will be slashed.1132 * 1133 * May only be called from `T::RejectOrigin`.1134 * 1135 * # <weight>1136 * - Complexity: O(1)1137 * - DbReads: `Proposals`, `rejected proposer account`1138 * - DbWrites: `Proposals`, `rejected proposer account`1139 * # </weight>1140 **/1141 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1142 /**1143 * Force a previously approved proposal to be removed from the approval queue.1144 * The original deposit will no longer be returned.1145 * 1146 * May only be called from `T::RejectOrigin`.1147 * - `proposal_id`: The index of a proposal1148 * 1149 * # <weight>1150 * - Complexity: O(A) where `A` is the number of approvals1151 * - Db reads and writes: `Approvals`1152 * # </weight>1153 * 1154 * Errors:1155 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1156 * i.e., the proposal has not been approved. This could also mean the proposal does not1157 * exist altogether, thus there is no way it would have been approved in the first place.1158 **/1159 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1160 /**1161 * Propose and approve a spend of treasury funds.1162 * 1163 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1164 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1165 * - `beneficiary`: The destination account for the transfer.1166 * 1167 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1168 * beneficiary.1169 **/1170 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]>;1171 /**1172 * Generic tx1173 **/1174 [key: string]: SubmittableExtrinsicFunction<ApiType>;1175 };1176 unique: {1177 /**1178 * Add an admin to a collection.1179 * 1180 * NFT Collection can be controlled by multiple admin addresses1181 * (some which can also be servers, for example). Admins can issue1182 * and burn NFTs, as well as add and remove other admins,1183 * but cannot change NFT or Collection ownership.1184 * 1185 * # Permissions1186 * 1187 * * Collection owner1188 * * Collection admin1189 * 1190 * # Arguments1191 * 1192 * * `collection_id`: ID of the Collection to add an admin for.1193 * * `new_admin`: Address of new admin to add.1194 **/1195 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1196 /**1197 * Add an address to allow list.1198 * 1199 * # Permissions1200 * 1201 * * Collection owner1202 * * Collection admin1203 * 1204 * # Arguments1205 * 1206 * * `collection_id`: ID of the modified collection.1207 * * `address`: ID of the address to be added to the allowlist.1208 **/1209 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1210 /**1211 * Allow a non-permissioned address to transfer or burn an item.1212 * 1213 * # Permissions1214 * 1215 * * Collection owner1216 * * Collection admin1217 * * Current item owner1218 * 1219 * # Arguments1220 * 1221 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1222 * * `collection_id`: ID of the collection the item belongs to.1223 * * `item_id`: ID of the item transactions on which are now approved.1224 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1225 * Set to 0 to revoke the approval.1226 **/1227 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]>;1228 /**1229 * Destroy a token on behalf of the owner as a non-owner account.1230 * 1231 * See also: [`approve`][`Pallet::approve`].1232 * 1233 * After this method executes, one approval is removed from the total so that1234 * the approved address will not be able to transfer this item again from this owner.1235 * 1236 * # Permissions1237 * 1238 * * Collection owner1239 * * Collection admin1240 * * Current token owner1241 * * Address approved by current item owner1242 * 1243 * # Arguments1244 * 1245 * * `from`: The owner of the burning item.1246 * * `collection_id`: ID of the collection to which the item belongs.1247 * * `item_id`: ID of item to burn.1248 * * `value`: Number of pieces to burn.1249 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1250 * * Fungible Mode: The desired number of pieces to burn.1251 * * Re-Fungible Mode: The desired number of pieces to burn.1252 **/1253 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]>;1254 /**1255 * Destroy an item.1256 * 1257 * # Permissions1258 * 1259 * * Collection owner1260 * * Collection admin1261 * * Current item owner1262 * 1263 * # Arguments1264 * 1265 * * `collection_id`: ID of the collection to which the item belongs.1266 * * `item_id`: ID of item to burn.1267 * * `value`: Number of pieces of the item to destroy.1268 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1269 * * Fungible Mode: The desired number of pieces to burn.1270 * * Re-Fungible Mode: The desired number of pieces to burn.1271 **/1272 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1273 /**1274 * Change the owner of the collection.1275 * 1276 * # Permissions1277 * 1278 * * Collection owner1279 * 1280 * # Arguments1281 * 1282 * * `collection_id`: ID of the modified collection.1283 * * `new_owner`: ID of the account that will become the owner.1284 **/1285 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1286 /**1287 * Confirm own sponsorship of a collection, becoming the sponsor.1288 * 1289 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1290 * Sponsor can pay the fees of a transaction instead of the sender,1291 * but only within specified limits.1292 * 1293 * # Permissions1294 * 1295 * * Sponsor-to-be1296 * 1297 * # Arguments1298 * 1299 * * `collection_id`: ID of the collection with the pending sponsor.1300 **/1301 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1302 /**1303 * Create a collection of tokens.1304 * 1305 * Each Token may have multiple properties encoded as an array of bytes1306 * of certain length. The initial owner of the collection is set1307 * to the address that signed the transaction and can be changed later.1308 * 1309 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1310 * 1311 * # Permissions1312 * 1313 * * Anyone - becomes the owner of the new collection.1314 * 1315 * # Arguments1316 * 1317 * * `collection_name`: Wide-character string with collection name1318 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1319 * * `collection_description`: Wide-character string with collection description1320 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1321 * * `token_prefix`: Byte string containing the token prefix to mark a collection1322 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1323 * * `mode`: Type of items stored in the collection and type dependent data.1324 **/1325 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]>;1326 /**1327 * Create a collection with explicit parameters.1328 * 1329 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1330 * 1331 * # Permissions1332 * 1333 * * Anyone - becomes the owner of the new collection.1334 * 1335 * # Arguments1336 * 1337 * * `data`: Explicit data of a collection used for its creation.1338 **/1339 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]>;1340 /**1341 * Mint an item within a collection.1342 * 1343 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1344 * 1345 * # Permissions1346 * 1347 * * Collection owner1348 * * Collection admin1349 * * Anyone if1350 * * Allow List is enabled, and1351 * * Address is added to allow list, and1352 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1353 * 1354 * # Arguments1355 * 1356 * * `collection_id`: ID of the collection to which an item would belong.1357 * * `owner`: Address of the initial owner of the item.1358 * * `data`: Token data describing the item to store on chain.1359 **/1360 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]>;1361 /**1362 * Create multiple items within a collection.1363 * 1364 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1365 * 1366 * # Permissions1367 * 1368 * * Collection owner1369 * * Collection admin1370 * * Anyone if1371 * * Allow List is enabled, and1372 * * Address is added to the allow list, and1373 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1374 * 1375 * # Arguments1376 * 1377 * * `collection_id`: ID of the collection to which the tokens would belong.1378 * * `owner`: Address of the initial owner of the tokens.1379 * * `items_data`: Vector of data describing each item to be created.1380 **/1381 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>]>;1382 /**1383 * Create multiple items within a collection with explicitly specified initial parameters.1384 * 1385 * # Permissions1386 * 1387 * * Collection owner1388 * * Collection admin1389 * * Anyone if1390 * * Allow List is enabled, and1391 * * Address is added to allow list, and1392 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1393 * 1394 * # Arguments1395 * 1396 * * `collection_id`: ID of the collection to which the tokens would belong.1397 * * `data`: Explicit item creation data.1398 **/1399 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1400 /**1401 * Delete specified collection properties.1402 * 1403 * # Permissions1404 * 1405 * * Collection Owner1406 * * Collection Admin1407 * 1408 * # Arguments1409 * 1410 * * `collection_id`: ID of the modified collection.1411 * * `property_keys`: Vector of keys of the properties to be deleted.1412 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1413 **/1414 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1415 /**1416 * Delete specified token properties. Currently properties only work with NFTs.1417 * 1418 * # Permissions1419 * 1420 * * Depends on collection's token property permissions and specified property mutability:1421 * * Collection owner1422 * * Collection admin1423 * * Token owner1424 * 1425 * # Arguments1426 * 1427 * * `collection_id`: ID of the collection to which the token belongs.1428 * * `token_id`: ID of the modified token.1429 * * `property_keys`: Vector of keys of the properties to be deleted.1430 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1431 **/1432 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1433 /**1434 * Destroy a collection if no tokens exist within.1435 * 1436 * # Permissions1437 * 1438 * * Collection owner1439 * 1440 * # Arguments1441 * 1442 * * `collection_id`: Collection to destroy.1443 **/1444 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1445 /**1446 * Repairs a collection if the data was somehow corrupted.1447 * 1448 * # Arguments1449 * 1450 * * `collection_id`: ID of the collection to repair.1451 **/1452 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1453 /**1454 * Repairs a token if the data was somehow corrupted.1455 * 1456 * # Arguments1457 * 1458 * * `collection_id`: ID of the collection the item belongs to.1459 * * `item_id`: ID of the item.1460 **/1461 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1462 /**1463 * Remove admin of a collection.1464 * 1465 * An admin address can remove itself. List of admins may become empty,1466 * in which case only Collection Owner will be able to add an Admin.1467 * 1468 * # Permissions1469 * 1470 * * Collection owner1471 * * Collection admin1472 * 1473 * # Arguments1474 * 1475 * * `collection_id`: ID of the collection to remove the admin for.1476 * * `account_id`: Address of the admin to remove.1477 **/1478 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1479 /**1480 * Remove a collection's a sponsor, making everyone pay for their own transactions.1481 * 1482 * # Permissions1483 * 1484 * * Collection owner1485 * 1486 * # Arguments1487 * 1488 * * `collection_id`: ID of the collection with the sponsor to remove.1489 **/1490 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1491 /**1492 * Remove an address from allow list.1493 * 1494 * # Permissions1495 * 1496 * * Collection owner1497 * * Collection admin1498 * 1499 * # Arguments1500 * 1501 * * `collection_id`: ID of the modified collection.1502 * * `address`: ID of the address to be removed from the allowlist.1503 **/1504 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1505 /**1506 * Re-partition a refungible token, while owning all of its parts/pieces.1507 * 1508 * # Permissions1509 * 1510 * * Token owner (must own every part)1511 * 1512 * # Arguments1513 * 1514 * * `collection_id`: ID of the collection the RFT belongs to.1515 * * `token_id`: ID of the RFT.1516 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1517 **/1518 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1519 /**1520 * Sets or unsets the approval of a given operator.1521 * 1522 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1523 * 1524 * # Arguments1525 * 1526 * * `owner`: Token owner1527 * * `operator`: Operator1528 * * `approve`: Should operator status be granted or revoked?1529 **/1530 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1531 /**1532 * Set specific limits of a collection. Empty, or None fields mean chain default.1533 * 1534 * # Permissions1535 * 1536 * * Collection owner1537 * * Collection admin1538 * 1539 * # Arguments1540 * 1541 * * `collection_id`: ID of the modified collection.1542 * * `new_limit`: New limits of the collection. Fields that are not set (None)1543 * will not overwrite the old ones.1544 **/1545 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]>;1546 /**1547 * Set specific permissions of a collection. Empty, or None fields mean chain default.1548 * 1549 * # Permissions1550 * 1551 * * Collection owner1552 * * Collection admin1553 * 1554 * # Arguments1555 * 1556 * * `collection_id`: ID of the modified collection.1557 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1558 * will not overwrite the old ones.1559 **/1560 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1561 /**1562 * Add or change collection properties.1563 * 1564 * # Permissions1565 * 1566 * * Collection owner1567 * * Collection admin1568 * 1569 * # Arguments1570 * 1571 * * `collection_id`: ID of the modified collection.1572 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1573 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1574 **/1575 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1576 /**1577 * Set (invite) a new collection sponsor.1578 * 1579 * If successful, confirmation from the sponsor-to-be will be pending.1580 * 1581 * # Permissions1582 * 1583 * * Collection owner1584 * * Collection admin1585 * 1586 * # Arguments1587 * 1588 * * `collection_id`: ID of the modified collection.1589 * * `new_sponsor`: ID of the account of the sponsor-to-be.1590 **/1591 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1592 /**1593 * Add or change token properties according to collection's permissions.1594 * Currently properties only work with NFTs.1595 * 1596 * # Permissions1597 * 1598 * * Depends on collection's token property permissions and specified property mutability:1599 * * Collection owner1600 * * Collection admin1601 * * Token owner1602 * 1603 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1604 * 1605 * # Arguments1606 * 1607 * * `collection_id: ID of the collection to which the token belongs.1608 * * `token_id`: ID of the modified token.1609 * * `properties`: Vector of key-value pairs stored as the token's metadata.1610 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1611 **/1612 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>]>;1613 /**1614 * Add or change token property permissions of a collection.1615 * 1616 * Without a permission for a particular key, a property with that key1617 * cannot be created in a token.1618 * 1619 * # Permissions1620 * 1621 * * Collection owner1622 * * Collection admin1623 * 1624 * # Arguments1625 * 1626 * * `collection_id`: ID of the modified collection.1627 * * `property_permissions`: Vector of permissions for property keys.1628 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1629 **/1630 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1631 /**1632 * Completely allow or disallow transfers for a particular collection.1633 * 1634 * # Permissions1635 * 1636 * * Collection owner1637 * 1638 * # Arguments1639 * 1640 * * `collection_id`: ID of the collection.1641 * * `value`: New value of the flag, are transfers allowed?1642 **/1643 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1644 /**1645 * Change ownership of the token.1646 * 1647 * # Permissions1648 * 1649 * * Collection owner1650 * * Collection admin1651 * * Current token owner1652 * 1653 * # Arguments1654 * 1655 * * `recipient`: Address of token recipient.1656 * * `collection_id`: ID of the collection the item belongs to.1657 * * `item_id`: ID of the item.1658 * * Non-Fungible Mode: Required.1659 * * Fungible Mode: Ignored.1660 * * Re-Fungible Mode: Required.1661 * 1662 * * `value`: Amount to transfer.1663 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1664 * * Fungible Mode: The desired number of pieces to transfer.1665 * * Re-Fungible Mode: The desired number of pieces to transfer.1666 **/1667 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]>;1668 /**1669 * Change ownership of an item on behalf of the owner as a non-owner account.1670 * 1671 * See the [`approve`][`Pallet::approve`] method for additional information.1672 * 1673 * After this method executes, one approval is removed from the total so that1674 * the approved address will not be able to transfer this item again from this owner.1675 * 1676 * # Permissions1677 * 1678 * * Collection owner1679 * * Collection admin1680 * * Current item owner1681 * * Address approved by current item owner1682 * 1683 * # Arguments1684 * 1685 * * `from`: Address that currently owns the token.1686 * * `recipient`: Address of the new token-owner-to-be.1687 * * `collection_id`: ID of the collection the item.1688 * * `item_id`: ID of the item to be transferred.1689 * * `value`: Amount to transfer.1690 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1691 * * Fungible Mode: The desired number of pieces to transfer.1692 * * Re-Fungible Mode: The desired number of pieces to transfer.1693 **/1694 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]>;1695 /**1696 * Generic tx1697 **/1698 [key: string]: SubmittableExtrinsicFunction<ApiType>;1699 };1700 vesting: {1701 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1702 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1703 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>]>;1704 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]>;1705 /**1706 * Generic tx1707 **/1708 [key: string]: SubmittableExtrinsicFunction<ApiType>;1709 };1710 xcmpQueue: {1711 /**1712 * Resumes all XCM executions for the XCMP queue.1713 * 1714 * Note that this function doesn't change the status of the in/out bound channels.1715 * 1716 * - `origin`: Must pass `ControllerOrigin`.1717 **/1718 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1719 /**1720 * Services a single overweight XCM.1721 * 1722 * - `origin`: Must pass `ExecuteOverweightOrigin`.1723 * - `index`: The index of the overweight XCM to service1724 * - `weight_limit`: The amount of weight that XCM execution may take.1725 * 1726 * Errors:1727 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1728 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1729 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1730 * 1731 * Events:1732 * - `OverweightServiced`: On success.1733 **/1734 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1735 /**1736 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1737 * 1738 * - `origin`: Must pass `ControllerOrigin`.1739 **/1740 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1741 /**1742 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1743 * messages from the channel.1744 * 1745 * - `origin`: Must pass `Root`.1746 * - `new`: Desired value for `QueueConfigData.drop_threshold`1747 **/1748 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1749 /**1750 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1751 * message sending may recommence after it has been suspended.1752 * 1753 * - `origin`: Must pass `Root`.1754 * - `new`: Desired value for `QueueConfigData.resume_threshold`1755 **/1756 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1757 /**1758 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1759 * suspend their sending.1760 * 1761 * - `origin`: Must pass `Root`.1762 * - `new`: Desired value for `QueueConfigData.suspend_value`1763 **/1764 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1765 /**1766 * Overwrites the amount of remaining weight under which we stop processing messages.1767 * 1768 * - `origin`: Must pass `Root`.1769 * - `new`: Desired value for `QueueConfigData.threshold_weight`1770 **/1771 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1772 /**1773 * Overwrites the speed to which the available weight approaches the maximum weight.1774 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1775 * 1776 * - `origin`: Must pass `Root`.1777 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1778 **/1779 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1780 /**1781 * Overwrite the maximum amount of weight any individual message may consume.1782 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1783 * 1784 * - `origin`: Must pass `Root`.1785 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1786 **/1787 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1788 /**1789 * Generic tx1790 **/1791 [key: string]: SubmittableExtrinsicFunction<ApiType>;1792 };1793 xTokens: {1794 /**1795 * Transfer native currencies.1796 * 1797 * `dest_weight_limit` is the weight for XCM execution on the dest1798 * chain, and it would be charged from the transferred assets. If set1799 * below requirements, the execution may fail and assets wouldn't be1800 * received.1801 * 1802 * It's a no-op if any error on local XCM execution or message sending.1803 * Note sending assets out per se doesn't guarantee they would be1804 * received. Receiving depends on if the XCM message could be delivered1805 * by the network, and if the receiving chain would handle1806 * messages correctly.1807 **/1808 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]>;1809 /**1810 * Transfer `MultiAsset`.1811 * 1812 * `dest_weight_limit` is the weight for XCM execution on the dest1813 * chain, and it would be charged from the transferred assets. If set1814 * below requirements, the execution may fail and assets wouldn't be1815 * received.1816 * 1817 * It's a no-op if any error on local XCM execution or message sending.1818 * Note sending assets out per se doesn't guarantee they would be1819 * received. Receiving depends on if the XCM message could be delivered1820 * by the network, and if the receiving chain would handle1821 * messages correctly.1822 **/1823 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]>;1824 /**1825 * Transfer several `MultiAsset` specifying the item to be used as fee1826 * 1827 * `dest_weight_limit` is the weight for XCM execution on the dest1828 * chain, and it would be charged from the transferred assets. If set1829 * below requirements, the execution may fail and assets wouldn't be1830 * received.1831 * 1832 * `fee_item` is index of the MultiAssets that we want to use for1833 * payment1834 * 1835 * It's a no-op if any error on local XCM execution or message sending.1836 * Note sending assets out per se doesn't guarantee they would be1837 * received. Receiving depends on if the XCM message could be delivered1838 * by the network, and if the receiving chain would handle1839 * messages correctly.1840 **/1841 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]>;1842 /**1843 * Transfer `MultiAsset` specifying the fee and amount as separate.1844 * 1845 * `dest_weight_limit` is the weight for XCM execution on the dest1846 * chain, and it would be charged from the transferred assets. If set1847 * below requirements, the execution may fail and assets wouldn't be1848 * received.1849 * 1850 * `fee` is the multiasset to be spent to pay for execution in1851 * destination chain. Both fee and amount will be subtracted form the1852 * callers balance For now we only accept fee and asset having the same1853 * `MultiLocation` id.1854 * 1855 * If `fee` is not high enough to cover for the execution costs in the1856 * destination chain, then the assets will be trapped in the1857 * destination chain1858 * 1859 * It's a no-op if any error on local XCM execution or message sending.1860 * Note sending assets out per se doesn't guarantee they would be1861 * received. Receiving depends on if the XCM message could be delivered1862 * by the network, and if the receiving chain would handle1863 * messages correctly.1864 **/1865 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]>;1866 /**1867 * Transfer several currencies specifying the item to be used as fee1868 * 1869 * `dest_weight_limit` is the weight for XCM execution on the dest1870 * chain, and it would be charged from the transferred assets. If set1871 * below requirements, the execution may fail and assets wouldn't be1872 * received.1873 * 1874 * `fee_item` is index of the currencies tuple that we want to use for1875 * payment1876 * 1877 * It's a no-op if any error on local XCM execution or message sending.1878 * Note sending assets out per se doesn't guarantee they would be1879 * received. Receiving depends on if the XCM message could be delivered1880 * by the network, and if the receiving chain would handle1881 * messages correctly.1882 **/1883 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]>;1884 /**1885 * Transfer native currencies specifying the fee and amount as1886 * separate.1887 * 1888 * `dest_weight_limit` is the weight for XCM execution on the dest1889 * chain, and it would be charged from the transferred assets. If set1890 * below requirements, the execution may fail and assets wouldn't be1891 * received.1892 * 1893 * `fee` is the amount to be spent to pay for execution in destination1894 * chain. Both fee and amount will be subtracted form the callers1895 * balance.1896 * 1897 * If `fee` is not high enough to cover for the execution costs in the1898 * destination chain, then the assets will be trapped in the1899 * destination chain1900 * 1901 * It's a no-op if any error on local XCM execution or message sending.1902 * Note sending assets out per se doesn't guarantee they would be1903 * received. Receiving depends on if the XCM message could be delivered1904 * by the network, and if the receiving chain would handle1905 * messages correctly.1906 **/1907 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]>;1908 /**1909 * Generic tx1910 **/1911 [key: string]: SubmittableExtrinsicFunction<ApiType>;1912 };1913 } // AugmentedSubmittables1914} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts105.9 KiBsourcehistory