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 { Data } from '@polkadot/types';10import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';11import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';12import type { AccountId32, Call, H160, H256, MultiAddress, Permill } from '@polkadot/types/interfaces/runtime';13import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OpalRuntimeRuntimeCommonSessionKeys, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletIdentityBitFlags, PalletIdentityIdentityInfo, PalletIdentityJudgement, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, SpRuntimeHeader, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1415export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;16export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;17export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1819declare module '@polkadot/api-base/types/submittable' {20 interface AugmentedSubmittables<ApiType extends ApiTypes> {21 appPromotion: {22 /**23 * Recalculates interest for the specified number of stakers.24 * If all stakers are not recalculated, the next call of the extrinsic25 * will continue the recalculation, from those stakers for whom this26 * was not perform in last call.27 * 28 * # Permissions29 * 30 * * Pallet admin31 * 32 * # Arguments33 * 34 * * `stakers_number`: the number of stakers for which recalculation will be performed35 **/36 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;37 /**38 * Sets an address as the the admin.39 * 40 * # Permissions41 * 42 * * Sudo43 * 44 * # Arguments45 * 46 * * `admin`: account of the new admin.47 **/48 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;49 /**50 * Sets the pallet to be the sponsor for the collection.51 * 52 * # Permissions53 * 54 * * Pallet admin55 * 56 * # Arguments57 * 58 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`59 **/60 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;61 /**62 * Sets the pallet to be the sponsor for the contract.63 * 64 * # Permissions65 * 66 * * Pallet admin67 * 68 * # Arguments69 * 70 * * `contract_id`: the contract address that will be sponsored by `pallet_id`71 **/72 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;73 /**74 * Stakes the amount of native tokens.75 * Sets `amount` to the locked state.76 * The maximum number of stakes for a staker is 10.77 * 78 * # Arguments79 * 80 * * `amount`: in native tokens.81 **/82 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;83 /**84 * Removes the pallet as the sponsor for the collection.85 * Returns [`NoPermission`][`Error::NoPermission`]86 * if the pallet wasn't the sponsor.87 * 88 * # Permissions89 * 90 * * Pallet admin91 * 92 * # Arguments93 * 94 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`95 **/96 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;97 /**98 * Removes the pallet as the sponsor for the contract.99 * Returns [`NoPermission`][`Error::NoPermission`]100 * if the pallet wasn't the sponsor.101 * 102 * # Permissions103 * 104 * * Pallet admin105 * 106 * # Arguments107 * 108 * * `contract_id`: the contract address that is sponsored by `pallet_id`109 **/110 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;111 /**112 * Unstakes all stakes.113 * Moves the sum of all stakes to the `reserved` state.114 * After the end of `PendingInterval` this sum becomes completely115 * free for further use.116 **/117 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;118 /**119 * Generic tx120 **/121 [key: string]: SubmittableExtrinsicFunction<ApiType>;122 };123 authorship: {124 /**125 * Provide a set of uncles.126 **/127 setUncles: AugmentedSubmittable<(newUncles: Vec<SpRuntimeHeader> | (SpRuntimeHeader | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<SpRuntimeHeader>]>;128 /**129 * Generic tx130 **/131 [key: string]: SubmittableExtrinsicFunction<ApiType>;132 };133 balances: {134 /**135 * Exactly as `transfer`, except the origin must be root and the source account may be136 * specified.137 * # <weight>138 * - Same as transfer, but additional read and write because the source account is not139 * assumed to be in the overlay.140 * # </weight>141 **/142 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>]>;143 /**144 * Unreserve some balance from a user by force.145 * 146 * Can only be called by ROOT.147 **/148 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;149 /**150 * Set the balances of a given account.151 * 152 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will153 * also alter the total issuance of the system (`TotalIssuance`) appropriately.154 * If the new free or reserved balance is below the existential deposit,155 * it will reset the account nonce (`frame_system::AccountNonce`).156 * 157 * The dispatch origin for this call is `root`.158 **/159 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>]>;160 /**161 * Transfer some liquid free balance to another account.162 * 163 * `transfer` will set the `FreeBalance` of the sender and receiver.164 * If the sender's account is below the existential deposit as a result165 * of the transfer, the account will be reaped.166 * 167 * The dispatch origin for this call must be `Signed` by the transactor.168 * 169 * # <weight>170 * - Dependent on arguments but not critical, given proper implementations for input config171 * types. See related functions below.172 * - It contains a limited number of reads and writes internally and no complex173 * computation.174 * 175 * Related functions:176 * 177 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.178 * - Transferring balances to accounts that did not exist before will cause179 * `T::OnNewAccount::on_new_account` to be called.180 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.181 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check182 * that the transfer will not kill the origin account.183 * ---------------------------------184 * - Origin account is already in memory, so no DB operations for them.185 * # </weight>186 **/187 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>]>;188 /**189 * Transfer the entire transferable balance from the caller account.190 * 191 * NOTE: This function only attempts to transfer _transferable_ balances. This means that192 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be193 * transferred by this function. To ensure that this function results in a killed account,194 * you might need to prepare the account by removing any reference counters, storage195 * deposits, etc...196 * 197 * The dispatch origin of this call must be Signed.198 * 199 * - `dest`: The recipient of the transfer.200 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all201 * of the funds the account has, causing the sender account to be killed (false), or202 * transfer everything except at least the existential deposit, which will guarantee to203 * keep the sender account alive (true). # <weight>204 * - O(1). Just like transfer, but reading the user's transferable balance first.205 * #</weight>206 **/207 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;208 /**209 * Same as the [`transfer`] call, but with a check that the transfer will not kill the210 * origin account.211 * 212 * 99% of the time you want [`transfer`] instead.213 * 214 * [`transfer`]: struct.Pallet.html#method.transfer215 **/216 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>]>;217 /**218 * Generic tx219 **/220 [key: string]: SubmittableExtrinsicFunction<ApiType>;221 };222 charging: {223 /**224 * Generic tx225 **/226 [key: string]: SubmittableExtrinsicFunction<ApiType>;227 };228 collatorSelection: {229 /**230 * Add a collator to the list of invulnerable (fixed) collators.231 **/232 addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;233 /**234 * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.235 * Note that the collator can only leave on session change.236 * The `LicenseBond` will be unreserved and returned immediately.237 * 238 * This call is, of course, not applicable to `Invulnerable` collators.239 **/240 forceRevokeLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;241 /**242 * Purchase a license on block collation for this account.243 * It does not make it a collator candidate, use `onboard` afterward. The account must244 * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.245 * 246 * This call is not available to `Invulnerable` collators.247 **/248 getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;249 /**250 * Deregister `origin` as a collator candidate. Note that the collator can only leave on251 * session change. The license to `onboard` later at any other time will remain.252 **/253 offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;254 /**255 * Register this account as a candidate for collators for next sessions.256 * The account must already hold a license, and cannot offboard immediately during a session.257 * 258 * This call is not available to `Invulnerable` collators.259 **/260 onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;261 /**262 * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.263 * 264 * This call is not available to `Invulnerable` collators.265 **/266 releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;267 /**268 * Remove a collator from the list of invulnerable (fixed) collators.269 **/270 removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;271 /**272 * Generic tx273 **/274 [key: string]: SubmittableExtrinsicFunction<ApiType>;275 };276 configuration: {277 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;278 setCollatorSelectionDesiredCollators: AugmentedSubmittable<(max: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;279 setCollatorSelectionKickThreshold: AugmentedSubmittable<(threshold: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;280 setCollatorSelectionLicenseBond: AugmentedSubmittable<(amount: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u128>]>;281 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;282 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;283 setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;284 /**285 * Generic tx286 **/287 [key: string]: SubmittableExtrinsicFunction<ApiType>;288 };289 cumulusXcm: {290 /**291 * Generic tx292 **/293 [key: string]: SubmittableExtrinsicFunction<ApiType>;294 };295 dataManagement: {296 /**297 * Start contract migration, inserts contract stub at target address,298 * and marks account as pending, allowing to insert storage299 **/300 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;301 /**302 * Finish contract migration, allows it to be called.303 * It is not possible to alter contract storage via [`Self::set_data`]304 * after this call.305 **/306 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;307 /**308 * Create ethereum events attached to the fake transaction309 **/310 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;311 /**312 * Create substrate events313 **/314 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;315 /**316 * Insert items into contract storage, this method can be called317 * multiple times318 **/319 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;320 /**321 * Generic tx322 **/323 [key: string]: SubmittableExtrinsicFunction<ApiType>;324 };325 dmpQueue: {326 /**327 * Service a single overweight message.328 * 329 * - `origin`: Must pass `ExecuteOverweightOrigin`.330 * - `index`: The index of the overweight message to service.331 * - `weight_limit`: The amount of weight that message execution may take.332 * 333 * Errors:334 * - `Unknown`: Message of `index` is unknown.335 * - `OverLimit`: Message execution may use greater than `weight_limit`.336 * 337 * Events:338 * - `OverweightServiced`: On success.339 **/340 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;341 /**342 * Generic tx343 **/344 [key: string]: SubmittableExtrinsicFunction<ApiType>;345 };346 ethereum: {347 /**348 * Transact an Ethereum transaction.349 **/350 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;351 /**352 * Generic tx353 **/354 [key: string]: SubmittableExtrinsicFunction<ApiType>;355 };356 evm: {357 /**358 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.359 **/360 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>]>>]>;361 /**362 * Issue an EVM create operation. This is similar to a contract creation transaction in363 * Ethereum.364 **/365 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>]>>]>;366 /**367 * Issue an EVM create2 operation.368 **/369 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>]>>]>;370 /**371 * Withdraw balance from EVM into currency/balances pallet.372 **/373 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;374 /**375 * Generic tx376 **/377 [key: string]: SubmittableExtrinsicFunction<ApiType>;378 };379 foreignAssets: {380 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]>;381 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]>;382 /**383 * Generic tx384 **/385 [key: string]: SubmittableExtrinsicFunction<ApiType>;386 };387 identity: {388 /**389 * Add a registrar to the system.390 * 391 * The dispatch origin for this call must be `T::RegistrarOrigin`.392 * 393 * - `account`: the account of the registrar.394 * 395 * Emits `RegistrarAdded` if successful.396 * 397 * # <weight>398 * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).399 * - One storage mutation (codec `O(R)`).400 * - One event.401 * # </weight>402 **/403 addRegistrar: AugmentedSubmittable<(account: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;404 /**405 * Add the given account to the sender's subs.406 * 407 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated408 * to the sender.409 * 410 * The dispatch origin for this call must be _Signed_ and the sender must have a registered411 * sub identity of `sub`.412 **/413 addSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Data]>;414 /**415 * Cancel a previous request.416 * 417 * Payment: A previously reserved deposit is returned on success.418 * 419 * The dispatch origin for this call must be _Signed_ and the sender must have a420 * registered identity.421 * 422 * - `reg_index`: The index of the registrar whose judgement is no longer requested.423 * 424 * Emits `JudgementUnrequested` if successful.425 * 426 * # <weight>427 * - `O(R + X)`.428 * - One balance-reserve operation.429 * - One storage mutation `O(R + X)`.430 * - One event431 * # </weight>432 **/433 cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;434 /**435 * Clear an account's identity info and all sub-accounts and return all deposits.436 * 437 * Payment: All reserved balances on the account are returned.438 * 439 * The dispatch origin for this call must be _Signed_ and the sender must have a registered440 * identity.441 * 442 * Emits `IdentityCleared` if successful.443 * 444 * # <weight>445 * - `O(R + S + X)`446 * - where `R` registrar-count (governance-bounded).447 * - where `S` subs-count (hard- and deposit-bounded).448 * - where `X` additional-field-count (deposit-bounded and code-bounded).449 * - One balance-unreserve operation.450 * - `2` storage reads and `S + 2` storage deletions.451 * - One event.452 * # </weight>453 **/454 clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;455 /**456 * Remove an account's identity and sub-account information and slash the deposits.457 * 458 * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by459 * `Slash`. Verification request deposits are not returned; they should be cancelled460 * manually using `cancel_request`.461 * 462 * The dispatch origin for this call must match `T::ForceOrigin`.463 * 464 * - `target`: the account whose identity the judgement is upon. This must be an account465 * with a registered identity.466 * 467 * Emits `IdentityKilled` if successful.468 * 469 * # <weight>470 * - `O(R + S + X)`.471 * - One balance-reserve operation.472 * - `S + 2` storage mutations.473 * - One event.474 * # </weight>475 **/476 killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;477 /**478 * Provide a judgement for an account's identity.479 * 480 * The dispatch origin for this call must be _Signed_ and the sender must be the account481 * of the registrar whose index is `reg_index`.482 * 483 * - `reg_index`: the index of the registrar whose judgement is being made.484 * - `target`: the account whose identity the judgement is upon. This must be an account485 * with a registered identity.486 * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.487 * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.488 * 489 * Emits `JudgementGiven` if successful.490 * 491 * # <weight>492 * - `O(R + X)`.493 * - One balance-transfer operation.494 * - Up to one account-lookup operation.495 * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.496 * - One event.497 * # </weight>498 **/499 provideJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, judgement: PalletIdentityJudgement | { Unknown: any } | { FeePaid: any } | { Reasonable: any } | { KnownGood: any } | { OutOfDate: any } | { LowQuality: any } | { Erroneous: any } | string | Uint8Array, identity: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, MultiAddress, PalletIdentityJudgement, H256]>;500 /**501 * Remove the sender as a sub-account.502 * 503 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated504 * to the sender (*not* the original depositor).505 * 506 * The dispatch origin for this call must be _Signed_ and the sender must have a registered507 * super-identity.508 * 509 * NOTE: This should not normally be used, but is provided in the case that the non-510 * controller of an account is maliciously registered as a sub-account.511 **/512 quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;513 /**514 * Remove the given account from the sender's subs.515 * 516 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated517 * to the sender.518 * 519 * The dispatch origin for this call must be _Signed_ and the sender must have a registered520 * sub identity of `sub`.521 **/522 removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;523 /**524 * Alter the associated name of the given sub-account.525 * 526 * The dispatch origin for this call must be _Signed_ and the sender must have a registered527 * sub identity of `sub`.528 **/529 renameSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Data]>;530 /**531 * Request a judgement from a registrar.532 * 533 * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement534 * given.535 * 536 * The dispatch origin for this call must be _Signed_ and the sender must have a537 * registered identity.538 * 539 * - `reg_index`: The index of the registrar whose judgement is requested.540 * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:541 * 542 * ```nocompile543 * Self::registrars().get(reg_index).unwrap().fee544 * ```545 * 546 * Emits `JudgementRequested` if successful.547 * 548 * # <weight>549 * - `O(R + X)`.550 * - One balance-reserve operation.551 * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.552 * - One event.553 * # </weight>554 **/555 requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;556 /**557 * Change the account associated with a registrar.558 * 559 * The dispatch origin for this call must be _Signed_ and the sender must be the account560 * of the registrar whose index is `index`.561 * 562 * - `index`: the index of the registrar whose fee is to be set.563 * - `new`: the new account ID.564 * 565 * # <weight>566 * - `O(R)`.567 * - One storage mutation `O(R)`.568 * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)569 * # </weight>570 **/571 setAccountId: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, MultiAddress]>;572 /**573 * Set the fee required for a judgement to be requested from a registrar.574 * 575 * The dispatch origin for this call must be _Signed_ and the sender must be the account576 * of the registrar whose index is `index`.577 * 578 * - `index`: the index of the registrar whose fee is to be set.579 * - `fee`: the new fee.580 * 581 * # <weight>582 * - `O(R)`.583 * - One storage mutation `O(R)`.584 * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)585 * # </weight>586 **/587 setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;588 /**589 * Set the field information for a registrar.590 * 591 * The dispatch origin for this call must be _Signed_ and the sender must be the account592 * of the registrar whose index is `index`.593 * 594 * - `index`: the index of the registrar whose fee is to be set.595 * - `fields`: the fields that the registrar concerns themselves with.596 * 597 * # <weight>598 * - `O(R)`.599 * - One storage mutation `O(R)`.600 * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)601 * # </weight>602 **/603 setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;604 /**605 * Set an account's identity information and reserve the appropriate deposit.606 * 607 * If the account already has identity information, the deposit is taken as part payment608 * for the new deposit.609 * 610 * The dispatch origin for this call must be _Signed_.611 * 612 * - `info`: The identity information.613 * 614 * Emits `IdentitySet` if successful.615 * 616 * # <weight>617 * - `O(X + X' + R)`618 * - where `X` additional-field-count (deposit-bounded and code-bounded)619 * - where `R` judgements-count (registrar-count-bounded)620 * - One balance reserve operation.621 * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).622 * - One event.623 * # </weight>624 **/625 setIdentity: AugmentedSubmittable<(info: PalletIdentityIdentityInfo | { additional?: any; display?: any; legal?: any; web?: any; riot?: any; email?: any; pgpFingerprint?: any; image?: any; twitter?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletIdentityIdentityInfo]>;626 /**627 * Set the sub-accounts of the sender.628 * 629 * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned630 * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.631 * 632 * The dispatch origin for this call must be _Signed_ and the sender must have a registered633 * identity.634 * 635 * - `subs`: The identity's (new) sub-accounts.636 * 637 * # <weight>638 * - `O(P + S)`639 * - where `P` old-subs-count (hard- and deposit-bounded).640 * - where `S` subs-count (hard- and deposit-bounded).641 * - At most one balance operations.642 * - DB:643 * - `P + S` storage mutations (codec complexity `O(1)`)644 * - One storage read (codec complexity `O(P)`).645 * - One storage write (codec complexity `O(S)`).646 * - One storage-exists (`IdentityOf::contains_key`).647 * # </weight>648 **/649 setSubs: AugmentedSubmittable<(subs: Vec<ITuple<[AccountId32, Data]>> | ([AccountId32 | string | Uint8Array, Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId32, Data]>>]>;650 /**651 * Generic tx652 **/653 [key: string]: SubmittableExtrinsicFunction<ApiType>;654 };655 inflation: {656 /**657 * This method sets the inflation start date. Can be only called once.658 * Inflation start block can be backdated and will catch up. The method will create Treasury659 * account if it does not exist and perform the first inflation deposit.660 * 661 * # Permissions662 * 663 * * Root664 * 665 * # Arguments666 * 667 * * inflation_start_relay_block: The relay chain block at which inflation should start668 **/669 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;670 /**671 * Generic tx672 **/673 [key: string]: SubmittableExtrinsicFunction<ApiType>;674 };675 maintenance: {676 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;677 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;678 /**679 * Generic tx680 **/681 [key: string]: SubmittableExtrinsicFunction<ApiType>;682 };683 parachainSystem: {684 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;685 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;686 /**687 * Set the current validation data.688 * 689 * This should be invoked exactly once per block. It will panic at the finalization690 * phase if the call was not invoked.691 * 692 * The dispatch origin for this call must be `Inherent`693 * 694 * As a side effect, this function upgrades the current validation function695 * if the appropriate time has come.696 **/697 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;698 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;699 /**700 * Generic tx701 **/702 [key: string]: SubmittableExtrinsicFunction<ApiType>;703 };704 polkadotXcm: {705 /**706 * Execute an XCM message from a local, signed, origin.707 * 708 * An event is deposited indicating whether `msg` could be executed completely or only709 * partially.710 * 711 * No more than `max_weight` will be used in its attempted execution. If this is less than the712 * maximum amount of weight that the message could take to be executed, then no execution713 * attempt will be made.714 * 715 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully716 * to completion; only that *some* of it was executed.717 **/718 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;719 /**720 * Set a safe XCM version (the version that XCM should be encoded with if the most recent721 * version a destination can accept is unknown).722 * 723 * - `origin`: Must be Root.724 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.725 **/726 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;727 /**728 * Ask a location to notify us regarding their XCM version and any changes to it.729 * 730 * - `origin`: Must be Root.731 * - `location`: The location to which we should subscribe for XCM version notifications.732 **/733 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;734 /**735 * Require that a particular destination should no longer notify us regarding any XCM736 * version changes.737 * 738 * - `origin`: Must be Root.739 * - `location`: The location to which we are currently subscribed for XCM version740 * notifications which we no longer desire.741 **/742 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;743 /**744 * Extoll that a particular destination can be communicated with through a particular745 * version of XCM.746 * 747 * - `origin`: Must be Root.748 * - `location`: The destination that is being described.749 * - `xcm_version`: The latest version of XCM that `location` supports.750 **/751 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;752 /**753 * Transfer some assets from the local chain to the sovereign account of a destination754 * chain and forward a notification XCM.755 * 756 * Fee payment on the destination side is made from the asset in the `assets` vector of757 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight758 * is needed than `weight_limit`, then the operation will fail and the assets send may be759 * at risk.760 * 761 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.762 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send763 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.764 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be765 * an `AccountId32` value.766 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the767 * `dest` side.768 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay769 * fees.770 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.771 **/772 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]>;773 /**774 * Teleport some assets from the local chain to some destination chain.775 * 776 * Fee payment on the destination side is made from the asset in the `assets` vector of777 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight778 * is needed than `weight_limit`, then the operation will fail and the assets send may be779 * at risk.780 * 781 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.782 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send783 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.784 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be785 * an `AccountId32` value.786 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the787 * `dest` side. May not be empty.788 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay789 * fees.790 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.791 **/792 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]>;793 /**794 * Transfer some assets from the local chain to the sovereign account of a destination795 * chain and forward a notification XCM.796 * 797 * Fee payment on the destination side is made from the asset in the `assets` vector of798 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,799 * with all fees taken as needed from the asset.800 * 801 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.802 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send803 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.804 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be805 * an `AccountId32` value.806 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the807 * `dest` side.808 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay809 * fees.810 **/811 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]>;812 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;813 /**814 * Teleport some assets from the local chain to some destination chain.815 * 816 * Fee payment on the destination side is made from the asset in the `assets` vector of817 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,818 * with all fees taken as needed from the asset.819 * 820 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.821 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send822 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.823 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be824 * an `AccountId32` value.825 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the826 * `dest` side. May not be empty.827 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay828 * fees.829 **/830 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]>;831 /**832 * Generic tx833 **/834 [key: string]: SubmittableExtrinsicFunction<ApiType>;835 };836 rmrkCore: {837 /**838 * Accept an NFT sent from another account to self or an owned NFT.839 * 840 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.841 * 842 * # Permissions:843 * - Token-owner-to-be844 * 845 * # Arguments:846 * - `origin`: sender of the transaction847 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.848 * - `rmrk_nft_id`: ID of the NFT to be accepted.849 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,850 * whichever the accepted NFT was sent to.851 **/852 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;853 /**854 * Accept the addition of a newly created pending resource to an existing NFT.855 * 856 * This transaction is needed when a resource is created and assigned to an NFT857 * by a non-owner, i.e. the collection issuer, with one of the858 * [`add_...` transactions](Pallet::add_basic_resource).859 * 860 * # Permissions:861 * - Token owner862 * 863 * # Arguments:864 * - `origin`: sender of the transaction865 * - `rmrk_collection_id`: RMRK collection ID of the NFT.866 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.867 * - `resource_id`: ID of the newly created pending resource.868 * accept the addition of a new resource to an existing NFT869 **/870 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;871 /**872 * Accept the removal of a removal-pending resource from an NFT.873 * 874 * This transaction is needed when a non-owner, i.e. the collection issuer,875 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.876 * 877 * # Permissions:878 * - Token owner879 * 880 * # Arguments:881 * - `origin`: sender of the transaction882 * - `rmrk_collection_id`: RMRK collection ID of the NFT.883 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.884 * - `resource_id`: ID of the removal-pending resource.885 **/886 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;887 /**888 * Create and set/propose a basic resource for an NFT.889 * 890 * A basic resource is the simplest, lacking a Base and anything that comes with it.891 * See RMRK docs for more information and examples.892 * 893 * # Permissions:894 * - Collection issuer - if not the token owner, adding the resource will warrant895 * the owner's [acceptance](Pallet::accept_resource).896 * 897 * # Arguments:898 * - `origin`: sender of the transaction899 * - `rmrk_collection_id`: RMRK collection ID of the NFT.900 * - `nft_id`: ID of the NFT to assign a resource to.901 * - `resource`: Data of the resource to be created.902 **/903 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]>;904 /**905 * Create and set/propose a composable resource for an NFT.906 * 907 * A composable resource links to a Base and has a subset of its Parts it is composed of.908 * See RMRK docs for more information and examples.909 * 910 * # Permissions:911 * - Collection issuer - if not the token owner, adding the resource will warrant912 * the owner's [acceptance](Pallet::accept_resource).913 * 914 * # Arguments:915 * - `origin`: sender of the transaction916 * - `rmrk_collection_id`: RMRK collection ID of the NFT.917 * - `nft_id`: ID of the NFT to assign a resource to.918 * - `resource`: Data of the resource to be created.919 **/920 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]>;921 /**922 * Create and set/propose a slot resource for an NFT.923 * 924 * A slot resource links to a Base and a slot ID in it which it can fit into.925 * See RMRK docs for more information and examples.926 * 927 * # Permissions:928 * - Collection issuer - if not the token owner, adding the resource will warrant929 * the owner's [acceptance](Pallet::accept_resource).930 * 931 * # Arguments:932 * - `origin`: sender of the transaction933 * - `rmrk_collection_id`: RMRK collection ID of the NFT.934 * - `nft_id`: ID of the NFT to assign a resource to.935 * - `resource`: Data of the resource to be created.936 **/937 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]>;938 /**939 * Burn an NFT, destroying it and its nested tokens up to the specified limit.940 * If the burning budget is exceeded, the transaction is reverted.941 * 942 * This is the way to burn a nested token as well.943 * 944 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).945 * 946 * # Permissions:947 * * Token owner948 * 949 * # Arguments:950 * - `origin`: sender of the transaction951 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.952 * - `nft_id`: ID of the NFT to be destroyed.953 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction954 * is reverted if there are more tokens to burn in the nesting tree than this number.955 * This is primarily a mechanism of transaction weight control.956 **/957 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;958 /**959 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).960 * 961 * # Permissions:962 * * Collection issuer963 * 964 * # Arguments:965 * - `origin`: sender of the transaction966 * - `collection_id`: RMRK collection ID to change the issuer of.967 * - `new_issuer`: Collection's new issuer.968 **/969 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;970 /**971 * Create a new collection of NFTs.972 * 973 * # Permissions:974 * * Anyone - will be assigned as the issuer of the collection.975 * 976 * # Arguments:977 * - `origin`: sender of the transaction978 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.979 * - `max`: Optional maximum number of tokens.980 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.981 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.982 **/983 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;984 /**985 * Destroy a collection.986 * 987 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.988 * 989 * # Permissions:990 * * Collection issuer991 * 992 * # Arguments:993 * - `origin`: sender of the transaction994 * - `collection_id`: RMRK ID of the collection to destroy.995 **/996 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;997 /**998 * "Lock" the collection and prevent new token creation. Cannot be undone.999 * 1000 * # Permissions:1001 * * Collection issuer1002 * 1003 * # Arguments:1004 * - `origin`: sender of the transaction1005 * - `collection_id`: RMRK ID of the collection to lock.1006 **/1007 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1008 /**1009 * Mint an NFT in a specified collection.1010 * 1011 * # Permissions:1012 * * Collection issuer1013 * 1014 * # Arguments:1015 * - `origin`: sender of the transaction1016 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).1017 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.1018 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.1019 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.1020 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.1021 * - `transferable`: Can this NFT be transferred? Cannot be changed.1022 * - `resources`: Resource data to be added to the NFT immediately after minting.1023 **/1024 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>>]>;1025 /**1026 * Reject an NFT sent from another account to self or owned NFT.1027 * The NFT in question will not be sent back and burnt instead.1028 * 1029 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.1030 * 1031 * # Permissions:1032 * - Token-owner-to-be-not1033 * 1034 * # Arguments:1035 * - `origin`: sender of the transaction1036 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.1037 * - `rmrk_nft_id`: ID of the NFT to be rejected.1038 **/1039 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1040 /**1041 * Remove and erase a resource from an NFT.1042 * 1043 * If the sender does not own the NFT, then it will be pending confirmation,1044 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.1045 * 1046 * # Permissions1047 * - Collection issuer1048 * 1049 * # Arguments1050 * - `origin`: sender of the transaction1051 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.1052 * - `nft_id`: ID of the NFT with a resource to be removed.1053 * - `resource_id`: ID of the resource to be removed.1054 **/1055 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;1056 /**1057 * Transfer an NFT from an account/NFT A to another account/NFT B.1058 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].1059 * 1060 * If the target owner is an NFT owned by another account, then the NFT will enter1061 * the pending state and will have to be accepted by the other account.1062 * 1063 * # Permissions:1064 * - Token owner1065 * 1066 * # Arguments:1067 * - `origin`: sender of the transaction1068 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.1069 * - `rmrk_nft_id`: ID of the NFT to be transferred.1070 * - `new_owner`: New owner of the nft which can be either an account or a NFT.1071 **/1072 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;1073 /**1074 * Set a different order of resource priorities for an NFT. Priorities can be used,1075 * for example, for order of rendering.1076 * 1077 * Note that the priorities are not updated automatically, and are an empty vector1078 * by default. There is no pre-set definition for the order to be particular,1079 * it can be interpreted arbitrarily use-case by use-case.1080 * 1081 * # Permissions:1082 * - Token owner1083 * 1084 * # Arguments:1085 * - `origin`: sender of the transaction1086 * - `rmrk_collection_id`: RMRK collection ID of the NFT.1087 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.1088 * - `priorities`: Ordered vector of resource IDs.1089 **/1090 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;1091 /**1092 * Add or edit a custom user property, a key-value pair, describing the metadata1093 * of a token or a collection, on either one of these.1094 * 1095 * Note that in this proxy implementation many details regarding RMRK are stored1096 * as scoped properties prefixed with "rmrk:", normally inaccessible1097 * to external transactions and RPCs.1098 * 1099 * # Permissions:1100 * - Collection issuer - in case of collection property1101 * - Token owner - in case of NFT property1102 * 1103 * # Arguments:1104 * - `origin`: sender of the transaction1105 * - `rmrk_collection_id`: RMRK collection ID.1106 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.1107 * - `key`: Key of the custom property to be referenced by.1108 * - `value`: Value of the custom property to be stored.1109 **/1110 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]>;1111 /**1112 * Generic tx1113 **/1114 [key: string]: SubmittableExtrinsicFunction<ApiType>;1115 };1116 rmrkEquip: {1117 /**1118 * Create a new Base.1119 * 1120 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)1121 * 1122 * # Permissions1123 * - Anyone - will be assigned as the issuer of the Base.1124 * 1125 * # Arguments:1126 * - `origin`: Caller, will be assigned as the issuer of the Base1127 * - `base_type`: Arbitrary media type, e.g. "svg".1128 * - `symbol`: Arbitrary client-chosen symbol.1129 * - `parts`: Array of Fixed and Slot Parts composing the Base,1130 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).1131 **/1132 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>]>;1133 /**1134 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.1135 * 1136 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).1137 * 1138 * # Permissions:1139 * - Base issuer1140 * 1141 * # Arguments:1142 * - `origin`: sender of the transaction1143 * - `base_id`: Base containing the Slot Part to be updated.1144 * - `slot_id`: Slot Part whose Equippable List is being updated .1145 * - `equippables`: List of equippables that will override the current Equippables list.1146 **/1147 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]>;1148 /**1149 * Add a Theme to a Base.1150 * A Theme named "default" is required prior to adding other Themes.1151 * 1152 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).1153 * 1154 * # Permissions:1155 * - Base issuer1156 * 1157 * # Arguments:1158 * - `origin`: sender of the transaction1159 * - `base_id`: Base ID containing the Theme to be updated.1160 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an1161 * array of [key, value, inherit].1162 * - `key`: Arbitrary BoundedString, defined by client.1163 * - `value`: Arbitrary BoundedString, defined by client.1164 * - `inherit`: Optional bool.1165 **/1166 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;1167 /**1168 * Generic tx1169 **/1170 [key: string]: SubmittableExtrinsicFunction<ApiType>;1171 };1172 session: {1173 /**1174 * Removes any session key(s) of the function caller.1175 * 1176 * This doesn't take effect until the next session.1177 * 1178 * The dispatch origin of this function must be Signed and the account must be either be1179 * convertible to a validator ID using the chain's typical addressing system (this usually1180 * means being a controller account) or directly convertible into a validator ID (which1181 * usually means being a stash account).1182 * 1183 * # <weight>1184 * - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length1185 * of `T::Keys::key_ids()` which is fixed.1186 * - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`1187 * - DbWrites: `NextKeys`, `origin account`1188 * - DbWrites per key id: `KeyOwner`1189 * # </weight>1190 **/1191 purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1192 /**1193 * Sets the session key(s) of the function caller to `keys`.1194 * Allows an account to set its session key prior to becoming a validator.1195 * This doesn't take effect until the next session.1196 * 1197 * The dispatch origin of this function must be signed.1198 * 1199 * # <weight>1200 * - Complexity: `O(1)`. Actual cost depends on the number of length of1201 * `T::Keys::key_ids()` which is fixed.1202 * - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`1203 * - DbWrites: `origin account`, `NextKeys`1204 * - DbReads per key id: `KeyOwner`1205 * - DbWrites per key id: `KeyOwner`1206 * # </weight>1207 **/1208 setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;1209 /**1210 * Generic tx1211 **/1212 [key: string]: SubmittableExtrinsicFunction<ApiType>;1213 };1214 structure: {1215 /**1216 * Generic tx1217 **/1218 [key: string]: SubmittableExtrinsicFunction<ApiType>;1219 };1220 sudo: {1221 /**1222 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo1223 * key.1224 * 1225 * The dispatch origin for this call must be _Signed_.1226 * 1227 * # <weight>1228 * - O(1).1229 * - Limited storage reads.1230 * - One DB change.1231 * # </weight>1232 **/1233 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1234 /**1235 * Authenticates the sudo key and dispatches a function call with `Root` origin.1236 * 1237 * The dispatch origin for this call must be _Signed_.1238 * 1239 * # <weight>1240 * - O(1).1241 * - Limited storage reads.1242 * - One DB write (event).1243 * - Weight of derivative `call` execution + 10,000.1244 * # </weight>1245 **/1246 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;1247 /**1248 * Authenticates the sudo key and dispatches a function call with `Signed` origin from1249 * a given account.1250 * 1251 * The dispatch origin for this call must be _Signed_.1252 * 1253 * # <weight>1254 * - O(1).1255 * - Limited storage reads.1256 * - One DB write (event).1257 * - Weight of derivative `call` execution + 10,000.1258 * # </weight>1259 **/1260 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]>;1261 /**1262 * Authenticates the sudo key and dispatches a function call with `Root` origin.1263 * This function does not check the weight of the call, and instead allows the1264 * Sudo user to specify the weight of the call.1265 * 1266 * The dispatch origin for this call must be _Signed_.1267 * 1268 * # <weight>1269 * - O(1).1270 * - The weight of this call is defined by the caller.1271 * # </weight>1272 **/1273 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;1274 /**1275 * Generic tx1276 **/1277 [key: string]: SubmittableExtrinsicFunction<ApiType>;1278 };1279 system: {1280 /**1281 * Kill all storage items with a key that starts with the given prefix.1282 * 1283 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1284 * the prefix we are removing to accurately calculate the weight of this function.1285 **/1286 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1287 /**1288 * Kill some items from storage.1289 **/1290 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1291 /**1292 * Make some on-chain remark.1293 * 1294 * # <weight>1295 * - `O(1)`1296 * # </weight>1297 **/1298 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1299 /**1300 * Make some on-chain remark and emit event.1301 **/1302 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1303 /**1304 * Set the new runtime code.1305 * 1306 * # <weight>1307 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`1308 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is1309 * expensive).1310 * - 1 storage write (codec `O(C)`).1311 * - 1 digest item.1312 * - 1 event.1313 * The weight of this function is dependent on the runtime, but generally this is very1314 * expensive. We will treat this as a full block.1315 * # </weight>1316 **/1317 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1318 /**1319 * Set the new runtime code without doing any checks of the given `code`.1320 * 1321 * # <weight>1322 * - `O(C)` where `C` length of `code`1323 * - 1 storage write (codec `O(C)`).1324 * - 1 digest item.1325 * - 1 event.1326 * The weight of this function is dependent on the runtime. We will treat this as a full1327 * block. # </weight>1328 **/1329 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1330 /**1331 * Set the number of pages in the WebAssembly environment's heap.1332 **/1333 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1334 /**1335 * Set some items of storage.1336 **/1337 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1338 /**1339 * Generic tx1340 **/1341 [key: string]: SubmittableExtrinsicFunction<ApiType>;1342 };1343 testUtils: {1344 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1345 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1346 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1347 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1348 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1349 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1350 /**1351 * Generic tx1352 **/1353 [key: string]: SubmittableExtrinsicFunction<ApiType>;1354 };1355 timestamp: {1356 /**1357 * Set the current time.1358 * 1359 * This call should be invoked exactly once per block. It will panic at the finalization1360 * phase, if this call hasn't been invoked by that time.1361 * 1362 * The timestamp should be greater than the previous one by the amount specified by1363 * `MinimumPeriod`.1364 * 1365 * The dispatch origin for this call must be `Inherent`.1366 * 1367 * # <weight>1368 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1369 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1370 * `on_finalize`)1371 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1372 * # </weight>1373 **/1374 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1375 /**1376 * Generic tx1377 **/1378 [key: string]: SubmittableExtrinsicFunction<ApiType>;1379 };1380 tokens: {1381 /**1382 * Exactly as `transfer`, except the origin must be root and the source1383 * account may be specified.1384 * 1385 * The dispatch origin for this call must be _Root_.1386 * 1387 * - `source`: The sender of the transfer.1388 * - `dest`: The recipient of the transfer.1389 * - `currency_id`: currency type.1390 * - `amount`: free balance amount to tranfer.1391 **/1392 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>]>;1393 /**1394 * Set the balances of a given account.1395 * 1396 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1397 * will also decrease the total issuance of the system1398 * (`TotalIssuance`). If the new free or reserved balance is below the1399 * existential deposit, it will reap the `AccountInfo`.1400 * 1401 * The dispatch origin for this call is `root`.1402 **/1403 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>]>;1404 /**1405 * Transfer some liquid free balance to another account.1406 * 1407 * `transfer` will set the `FreeBalance` of the sender and receiver.1408 * It will decrease the total issuance of the system by the1409 * `TransferFee`. If the sender's account is below the existential1410 * deposit as a result of the transfer, the account will be reaped.1411 * 1412 * The dispatch origin for this call must be `Signed` by the1413 * transactor.1414 * 1415 * - `dest`: The recipient of the transfer.1416 * - `currency_id`: currency type.1417 * - `amount`: free balance amount to tranfer.1418 **/1419 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>]>;1420 /**1421 * Transfer all remaining balance to the given account.1422 * 1423 * NOTE: This function only attempts to transfer _transferable_1424 * balances. This means that any locked, reserved, or existential1425 * deposits (when `keep_alive` is `true`), will not be transferred by1426 * this function. To ensure that this function results in a killed1427 * account, you might need to prepare the account by removing any1428 * reference counters, storage deposits, etc...1429 * 1430 * The dispatch origin for this call must be `Signed` by the1431 * transactor.1432 * 1433 * - `dest`: The recipient of the transfer.1434 * - `currency_id`: currency type.1435 * - `keep_alive`: A boolean to determine if the `transfer_all`1436 * operation should send all of the funds the account has, causing1437 * the sender account to be killed (false), or transfer everything1438 * except at least the existential deposit, which will guarantee to1439 * keep the sender account alive (true).1440 **/1441 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]>;1442 /**1443 * Same as the [`transfer`] call, but with a check that the transfer1444 * will not kill the origin account.1445 * 1446 * 99% of the time you want [`transfer`] instead.1447 * 1448 * The dispatch origin for this call must be `Signed` by the1449 * transactor.1450 * 1451 * - `dest`: The recipient of the transfer.1452 * - `currency_id`: currency type.1453 * - `amount`: free balance amount to tranfer.1454 **/1455 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>]>;1456 /**1457 * Generic tx1458 **/1459 [key: string]: SubmittableExtrinsicFunction<ApiType>;1460 };1461 treasury: {1462 /**1463 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1464 * and the original deposit will be returned.1465 * 1466 * May only be called from `T::ApproveOrigin`.1467 * 1468 * # <weight>1469 * - Complexity: O(1).1470 * - DbReads: `Proposals`, `Approvals`1471 * - DbWrite: `Approvals`1472 * # </weight>1473 **/1474 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1475 /**1476 * Put forward a suggestion for spending. A deposit proportional to the value1477 * is reserved and slashed if the proposal is rejected. It is returned once the1478 * proposal is awarded.1479 * 1480 * # <weight>1481 * - Complexity: O(1)1482 * - DbReads: `ProposalCount`, `origin account`1483 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1484 * # </weight>1485 **/1486 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]>;1487 /**1488 * Reject a proposed spend. The original deposit will be slashed.1489 * 1490 * May only be called from `T::RejectOrigin`.1491 * 1492 * # <weight>1493 * - Complexity: O(1)1494 * - DbReads: `Proposals`, `rejected proposer account`1495 * - DbWrites: `Proposals`, `rejected proposer account`1496 * # </weight>1497 **/1498 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1499 /**1500 * Force a previously approved proposal to be removed from the approval queue.1501 * The original deposit will no longer be returned.1502 * 1503 * May only be called from `T::RejectOrigin`.1504 * - `proposal_id`: The index of a proposal1505 * 1506 * # <weight>1507 * - Complexity: O(A) where `A` is the number of approvals1508 * - Db reads and writes: `Approvals`1509 * # </weight>1510 * 1511 * Errors:1512 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1513 * i.e., the proposal has not been approved. This could also mean the proposal does not1514 * exist altogether, thus there is no way it would have been approved in the first place.1515 **/1516 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1517 /**1518 * Propose and approve a spend of treasury funds.1519 * 1520 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1521 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1522 * - `beneficiary`: The destination account for the transfer.1523 * 1524 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1525 * beneficiary.1526 **/1527 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]>;1528 /**1529 * Generic tx1530 **/1531 [key: string]: SubmittableExtrinsicFunction<ApiType>;1532 };1533 unique: {1534 /**1535 * Add an admin to a collection.1536 * 1537 * NFT Collection can be controlled by multiple admin addresses1538 * (some which can also be servers, for example). Admins can issue1539 * and burn NFTs, as well as add and remove other admins,1540 * but cannot change NFT or Collection ownership.1541 * 1542 * # Permissions1543 * 1544 * * Collection owner1545 * * Collection admin1546 * 1547 * # Arguments1548 * 1549 * * `collection_id`: ID of the Collection to add an admin for.1550 * * `new_admin`: Address of new admin to add.1551 **/1552 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1553 /**1554 * Add an address to allow list.1555 * 1556 * # Permissions1557 * 1558 * * Collection owner1559 * * Collection admin1560 * 1561 * # Arguments1562 * 1563 * * `collection_id`: ID of the modified collection.1564 * * `address`: ID of the address to be added to the allowlist.1565 **/1566 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1567 /**1568 * Allow a non-permissioned address to transfer or burn an item.1569 * 1570 * # Permissions1571 * 1572 * * Collection owner1573 * * Collection admin1574 * * Current item owner1575 * 1576 * # Arguments1577 * 1578 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1579 * * `collection_id`: ID of the collection the item belongs to.1580 * * `item_id`: ID of the item transactions on which are now approved.1581 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1582 * Set to 0 to revoke the approval.1583 **/1584 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]>;1585 /**1586 * Destroy a token on behalf of the owner as a non-owner account.1587 * 1588 * See also: [`approve`][`Pallet::approve`].1589 * 1590 * After this method executes, one approval is removed from the total so that1591 * the approved address will not be able to transfer this item again from this owner.1592 * 1593 * # Permissions1594 * 1595 * * Collection owner1596 * * Collection admin1597 * * Current token owner1598 * * Address approved by current item owner1599 * 1600 * # Arguments1601 * 1602 * * `from`: The owner of the burning item.1603 * * `collection_id`: ID of the collection to which the item belongs.1604 * * `item_id`: ID of item to burn.1605 * * `value`: Number of pieces to burn.1606 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1607 * * Fungible Mode: The desired number of pieces to burn.1608 * * Re-Fungible Mode: The desired number of pieces to burn.1609 **/1610 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]>;1611 /**1612 * Destroy an item.1613 * 1614 * # Permissions1615 * 1616 * * Collection owner1617 * * Collection admin1618 * * Current item owner1619 * 1620 * # Arguments1621 * 1622 * * `collection_id`: ID of the collection to which the item belongs.1623 * * `item_id`: ID of item to burn.1624 * * `value`: Number of pieces of the item to destroy.1625 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1626 * * Fungible Mode: The desired number of pieces to burn.1627 * * Re-Fungible Mode: The desired number of pieces to burn.1628 **/1629 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1630 /**1631 * Change the owner of the collection.1632 * 1633 * # Permissions1634 * 1635 * * Collection owner1636 * 1637 * # Arguments1638 * 1639 * * `collection_id`: ID of the modified collection.1640 * * `new_owner`: ID of the account that will become the owner.1641 **/1642 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1643 /**1644 * Confirm own sponsorship of a collection, becoming the sponsor.1645 * 1646 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1647 * Sponsor can pay the fees of a transaction instead of the sender,1648 * but only within specified limits.1649 * 1650 * # Permissions1651 * 1652 * * Sponsor-to-be1653 * 1654 * # Arguments1655 * 1656 * * `collection_id`: ID of the collection with the pending sponsor.1657 **/1658 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1659 /**1660 * Create a collection of tokens.1661 * 1662 * Each Token may have multiple properties encoded as an array of bytes1663 * of certain length. The initial owner of the collection is set1664 * to the address that signed the transaction and can be changed later.1665 * 1666 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1667 * 1668 * # Permissions1669 * 1670 * * Anyone - becomes the owner of the new collection.1671 * 1672 * # Arguments1673 * 1674 * * `collection_name`: Wide-character string with collection name1675 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1676 * * `collection_description`: Wide-character string with collection description1677 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1678 * * `token_prefix`: Byte string containing the token prefix to mark a collection1679 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1680 * * `mode`: Type of items stored in the collection and type dependent data.1681 **/1682 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]>;1683 /**1684 * Create a collection with explicit parameters.1685 * 1686 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1687 * 1688 * # Permissions1689 * 1690 * * Anyone - becomes the owner of the new collection.1691 * 1692 * # Arguments1693 * 1694 * * `data`: Explicit data of a collection used for its creation.1695 **/1696 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]>;1697 /**1698 * Mint an item within a collection.1699 * 1700 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1701 * 1702 * # Permissions1703 * 1704 * * Collection owner1705 * * Collection admin1706 * * Anyone if1707 * * Allow List is enabled, and1708 * * Address is added to allow list, and1709 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1710 * 1711 * # Arguments1712 * 1713 * * `collection_id`: ID of the collection to which an item would belong.1714 * * `owner`: Address of the initial owner of the item.1715 * * `data`: Token data describing the item to store on chain.1716 **/1717 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]>;1718 /**1719 * Create multiple items within a collection.1720 * 1721 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1722 * 1723 * # Permissions1724 * 1725 * * Collection owner1726 * * Collection admin1727 * * Anyone if1728 * * Allow List is enabled, and1729 * * Address is added to the allow list, and1730 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1731 * 1732 * # Arguments1733 * 1734 * * `collection_id`: ID of the collection to which the tokens would belong.1735 * * `owner`: Address of the initial owner of the tokens.1736 * * `items_data`: Vector of data describing each item to be created.1737 **/1738 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>]>;1739 /**1740 * Create multiple items within a collection with explicitly specified initial parameters.1741 * 1742 * # Permissions1743 * 1744 * * Collection owner1745 * * Collection admin1746 * * Anyone if1747 * * Allow List is enabled, and1748 * * Address is added to allow list, and1749 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1750 * 1751 * # Arguments1752 * 1753 * * `collection_id`: ID of the collection to which the tokens would belong.1754 * * `data`: Explicit item creation data.1755 **/1756 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1757 /**1758 * Delete specified collection properties.1759 * 1760 * # Permissions1761 * 1762 * * Collection Owner1763 * * Collection Admin1764 * 1765 * # Arguments1766 * 1767 * * `collection_id`: ID of the modified collection.1768 * * `property_keys`: Vector of keys of the properties to be deleted.1769 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1770 **/1771 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1772 /**1773 * Delete specified token properties. Currently properties only work with NFTs.1774 * 1775 * # Permissions1776 * 1777 * * Depends on collection's token property permissions and specified property mutability:1778 * * Collection owner1779 * * Collection admin1780 * * Token owner1781 * 1782 * # Arguments1783 * 1784 * * `collection_id`: ID of the collection to which the token belongs.1785 * * `token_id`: ID of the modified token.1786 * * `property_keys`: Vector of keys of the properties to be deleted.1787 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1788 **/1789 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1790 /**1791 * Destroy a collection if no tokens exist within.1792 * 1793 * # Permissions1794 * 1795 * * Collection owner1796 * 1797 * # Arguments1798 * 1799 * * `collection_id`: Collection to destroy.1800 **/1801 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1802 /**1803 * Repairs a collection if the data was somehow corrupted.1804 * 1805 * # Arguments1806 * 1807 * * `collection_id`: ID of the collection to repair.1808 **/1809 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1810 /**1811 * Repairs a token if the data was somehow corrupted.1812 * 1813 * # Arguments1814 * 1815 * * `collection_id`: ID of the collection the item belongs to.1816 * * `item_id`: ID of the item.1817 **/1818 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1819 /**1820 * Remove admin of a collection.1821 * 1822 * An admin address can remove itself. List of admins may become empty,1823 * in which case only Collection Owner will be able to add an Admin.1824 * 1825 * # Permissions1826 * 1827 * * Collection owner1828 * * Collection admin1829 * 1830 * # Arguments1831 * 1832 * * `collection_id`: ID of the collection to remove the admin for.1833 * * `account_id`: Address of the admin to remove.1834 **/1835 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1836 /**1837 * Remove a collection's a sponsor, making everyone pay for their own transactions.1838 * 1839 * # Permissions1840 * 1841 * * Collection owner1842 * 1843 * # Arguments1844 * 1845 * * `collection_id`: ID of the collection with the sponsor to remove.1846 **/1847 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1848 /**1849 * Remove an address from allow list.1850 * 1851 * # Permissions1852 * 1853 * * Collection owner1854 * * Collection admin1855 * 1856 * # Arguments1857 * 1858 * * `collection_id`: ID of the modified collection.1859 * * `address`: ID of the address to be removed from the allowlist.1860 **/1861 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1862 /**1863 * Re-partition a refungible token, while owning all of its parts/pieces.1864 * 1865 * # Permissions1866 * 1867 * * Token owner (must own every part)1868 * 1869 * # Arguments1870 * 1871 * * `collection_id`: ID of the collection the RFT belongs to.1872 * * `token_id`: ID of the RFT.1873 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1874 **/1875 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1876 /**1877 * Sets or unsets the approval of a given operator.1878 * 1879 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1880 * 1881 * # Arguments1882 * 1883 * * `owner`: Token owner1884 * * `operator`: Operator1885 * * `approve`: Should operator status be granted or revoked?1886 **/1887 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1888 /**1889 * Set specific limits of a collection. Empty, or None fields mean chain default.1890 * 1891 * # Permissions1892 * 1893 * * Collection owner1894 * * Collection admin1895 * 1896 * # Arguments1897 * 1898 * * `collection_id`: ID of the modified collection.1899 * * `new_limit`: New limits of the collection. Fields that are not set (None)1900 * will not overwrite the old ones.1901 **/1902 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]>;1903 /**1904 * Set specific permissions of a collection. Empty, or None fields mean chain default.1905 * 1906 * # Permissions1907 * 1908 * * Collection owner1909 * * Collection admin1910 * 1911 * # Arguments1912 * 1913 * * `collection_id`: ID of the modified collection.1914 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1915 * will not overwrite the old ones.1916 **/1917 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1918 /**1919 * Add or change collection properties.1920 * 1921 * # Permissions1922 * 1923 * * Collection owner1924 * * Collection admin1925 * 1926 * # Arguments1927 * 1928 * * `collection_id`: ID of the modified collection.1929 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1930 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1931 **/1932 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1933 /**1934 * Set (invite) a new collection sponsor.1935 * 1936 * If successful, confirmation from the sponsor-to-be will be pending.1937 * 1938 * # Permissions1939 * 1940 * * Collection owner1941 * * Collection admin1942 * 1943 * # Arguments1944 * 1945 * * `collection_id`: ID of the modified collection.1946 * * `new_sponsor`: ID of the account of the sponsor-to-be.1947 **/1948 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1949 /**1950 * Add or change token properties according to collection's permissions.1951 * Currently properties only work with NFTs.1952 * 1953 * # Permissions1954 * 1955 * * Depends on collection's token property permissions and specified property mutability:1956 * * Collection owner1957 * * Collection admin1958 * * Token owner1959 * 1960 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1961 * 1962 * # Arguments1963 * 1964 * * `collection_id: ID of the collection to which the token belongs.1965 * * `token_id`: ID of the modified token.1966 * * `properties`: Vector of key-value pairs stored as the token's metadata.1967 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1968 **/1969 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>]>;1970 /**1971 * Add or change token property permissions of a collection.1972 * 1973 * Without a permission for a particular key, a property with that key1974 * cannot be created in a token.1975 * 1976 * # Permissions1977 * 1978 * * Collection owner1979 * * Collection admin1980 * 1981 * # Arguments1982 * 1983 * * `collection_id`: ID of the modified collection.1984 * * `property_permissions`: Vector of permissions for property keys.1985 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1986 **/1987 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1988 /**1989 * Completely allow or disallow transfers for a particular collection.1990 * 1991 * # Permissions1992 * 1993 * * Collection owner1994 * 1995 * # Arguments1996 * 1997 * * `collection_id`: ID of the collection.1998 * * `value`: New value of the flag, are transfers allowed?1999 **/2000 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;2001 /**2002 * Change ownership of the token.2003 * 2004 * # Permissions2005 * 2006 * * Collection owner2007 * * Collection admin2008 * * Current token owner2009 * 2010 * # Arguments2011 * 2012 * * `recipient`: Address of token recipient.2013 * * `collection_id`: ID of the collection the item belongs to.2014 * * `item_id`: ID of the item.2015 * * Non-Fungible Mode: Required.2016 * * Fungible Mode: Ignored.2017 * * Re-Fungible Mode: Required.2018 * 2019 * * `value`: Amount to transfer.2020 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2021 * * Fungible Mode: The desired number of pieces to transfer.2022 * * Re-Fungible Mode: The desired number of pieces to transfer.2023 **/2024 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]>;2025 /**2026 * Change ownership of an item on behalf of the owner as a non-owner account.2027 * 2028 * See the [`approve`][`Pallet::approve`] method for additional information.2029 * 2030 * After this method executes, one approval is removed from the total so that2031 * the approved address will not be able to transfer this item again from this owner.2032 * 2033 * # Permissions2034 * 2035 * * Collection owner2036 * * Collection admin2037 * * Current item owner2038 * * Address approved by current item owner2039 * 2040 * # Arguments2041 * 2042 * * `from`: Address that currently owns the token.2043 * * `recipient`: Address of the new token-owner-to-be.2044 * * `collection_id`: ID of the collection the item.2045 * * `item_id`: ID of the item to be transferred.2046 * * `value`: Amount to transfer.2047 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2048 * * Fungible Mode: The desired number of pieces to transfer.2049 * * Re-Fungible Mode: The desired number of pieces to transfer.2050 **/2051 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]>;2052 /**2053 * Generic tx2054 **/2055 [key: string]: SubmittableExtrinsicFunction<ApiType>;2056 };2057 vesting: {2058 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2059 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;2060 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>]>;2061 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]>;2062 /**2063 * Generic tx2064 **/2065 [key: string]: SubmittableExtrinsicFunction<ApiType>;2066 };2067 xcmpQueue: {2068 /**2069 * Resumes all XCM executions for the XCMP queue.2070 * 2071 * Note that this function doesn't change the status of the in/out bound channels.2072 * 2073 * - `origin`: Must pass `ControllerOrigin`.2074 **/2075 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2076 /**2077 * Services a single overweight XCM.2078 * 2079 * - `origin`: Must pass `ExecuteOverweightOrigin`.2080 * - `index`: The index of the overweight XCM to service2081 * - `weight_limit`: The amount of weight that XCM execution may take.2082 * 2083 * Errors:2084 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.2085 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.2086 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.2087 * 2088 * Events:2089 * - `OverweightServiced`: On success.2090 **/2091 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;2092 /**2093 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.2094 * 2095 * - `origin`: Must pass `ControllerOrigin`.2096 **/2097 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2098 /**2099 * Overwrites the number of pages of messages which must be in the queue after which we drop any further2100 * messages from the channel.2101 * 2102 * - `origin`: Must pass `Root`.2103 * - `new`: Desired value for `QueueConfigData.drop_threshold`2104 **/2105 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2106 /**2107 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that2108 * message sending may recommence after it has been suspended.2109 * 2110 * - `origin`: Must pass `Root`.2111 * - `new`: Desired value for `QueueConfigData.resume_threshold`2112 **/2113 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2114 /**2115 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to2116 * suspend their sending.2117 * 2118 * - `origin`: Must pass `Root`.2119 * - `new`: Desired value for `QueueConfigData.suspend_value`2120 **/2121 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2122 /**2123 * Overwrites the amount of remaining weight under which we stop processing messages.2124 * 2125 * - `origin`: Must pass `Root`.2126 * - `new`: Desired value for `QueueConfigData.threshold_weight`2127 **/2128 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;2129 /**2130 * Overwrites the speed to which the available weight approaches the maximum weight.2131 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.2132 * 2133 * - `origin`: Must pass `Root`.2134 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.2135 **/2136 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;2137 /**2138 * Overwrite the maximum amount of weight any individual message may consume.2139 * Messages above this weight go into the overweight queue and may only be serviced explicitly.2140 * 2141 * - `origin`: Must pass `Root`.2142 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.2143 **/2144 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;2145 /**2146 * Generic tx2147 **/2148 [key: string]: SubmittableExtrinsicFunction<ApiType>;2149 };2150 xTokens: {2151 /**2152 * Transfer native currencies.2153 * 2154 * `dest_weight_limit` is the weight for XCM execution on the dest2155 * chain, and it would be charged from the transferred assets. If set2156 * below requirements, the execution may fail and assets wouldn't be2157 * received.2158 * 2159 * It's a no-op if any error on local XCM execution or message sending.2160 * Note sending assets out per se doesn't guarantee they would be2161 * received. Receiving depends on if the XCM message could be delivered2162 * by the network, and if the receiving chain would handle2163 * messages correctly.2164 **/2165 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]>;2166 /**2167 * Transfer `MultiAsset`.2168 * 2169 * `dest_weight_limit` is the weight for XCM execution on the dest2170 * chain, and it would be charged from the transferred assets. If set2171 * below requirements, the execution may fail and assets wouldn't be2172 * received.2173 * 2174 * It's a no-op if any error on local XCM execution or message sending.2175 * Note sending assets out per se doesn't guarantee they would be2176 * received. Receiving depends on if the XCM message could be delivered2177 * by the network, and if the receiving chain would handle2178 * messages correctly.2179 **/2180 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]>;2181 /**2182 * Transfer several `MultiAsset` specifying the item to be used as fee2183 * 2184 * `dest_weight_limit` is the weight for XCM execution on the dest2185 * chain, and it would be charged from the transferred assets. If set2186 * below requirements, the execution may fail and assets wouldn't be2187 * received.2188 * 2189 * `fee_item` is index of the MultiAssets that we want to use for2190 * payment2191 * 2192 * It's a no-op if any error on local XCM execution or message sending.2193 * Note sending assets out per se doesn't guarantee they would be2194 * received. Receiving depends on if the XCM message could be delivered2195 * by the network, and if the receiving chain would handle2196 * messages correctly.2197 **/2198 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]>;2199 /**2200 * Transfer `MultiAsset` specifying the fee and amount as separate.2201 * 2202 * `dest_weight_limit` is the weight for XCM execution on the dest2203 * chain, and it would be charged from the transferred assets. If set2204 * below requirements, the execution may fail and assets wouldn't be2205 * received.2206 * 2207 * `fee` is the multiasset to be spent to pay for execution in2208 * destination chain. Both fee and amount will be subtracted form the2209 * callers balance For now we only accept fee and asset having the same2210 * `MultiLocation` id.2211 * 2212 * If `fee` is not high enough to cover for the execution costs in the2213 * destination chain, then the assets will be trapped in the2214 * destination chain2215 * 2216 * It's a no-op if any error on local XCM execution or message sending.2217 * Note sending assets out per se doesn't guarantee they would be2218 * received. Receiving depends on if the XCM message could be delivered2219 * by the network, and if the receiving chain would handle2220 * messages correctly.2221 **/2222 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]>;2223 /**2224 * Transfer several currencies specifying the item to be used as fee2225 * 2226 * `dest_weight_limit` is the weight for XCM execution on the dest2227 * chain, and it would be charged from the transferred assets. If set2228 * below requirements, the execution may fail and assets wouldn't be2229 * received.2230 * 2231 * `fee_item` is index of the currencies tuple that we want to use for2232 * payment2233 * 2234 * It's a no-op if any error on local XCM execution or message sending.2235 * Note sending assets out per se doesn't guarantee they would be2236 * received. Receiving depends on if the XCM message could be delivered2237 * by the network, and if the receiving chain would handle2238 * messages correctly.2239 **/2240 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]>;2241 /**2242 * Transfer native currencies specifying the fee and amount as2243 * separate.2244 * 2245 * `dest_weight_limit` is the weight for XCM execution on the dest2246 * chain, and it would be charged from the transferred assets. If set2247 * below requirements, the execution may fail and assets wouldn't be2248 * received.2249 * 2250 * `fee` is the amount to be spent to pay for execution in destination2251 * chain. Both fee and amount will be subtracted form the callers2252 * balance.2253 * 2254 * If `fee` is not high enough to cover for the execution costs in the2255 * destination chain, then the assets will be trapped in the2256 * destination chain2257 * 2258 * It's a no-op if any error on local XCM execution or message sending.2259 * Note sending assets out per se doesn't guarantee they would be2260 * received. Receiving depends on if the XCM message could be delivered2261 * by the network, and if the receiving chain would handle2262 * messages correctly.2263 **/2264 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]>;2265 /**2266 * Generic tx2267 **/2268 [key: string]: SubmittableExtrinsicFunction<ApiType>;2269 };2270 } // AugmentedSubmittables2271} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts122.0 KiBsourcehistory