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 } from '@polkadot/types/interfaces/runtime';13import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OpalRuntimeRuntimeCommonSessionKeys, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletIdentityBitFlags, PalletIdentityIdentityInfo, PalletIdentityJudgement, PalletIdentityRegistration, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV3MultiLocation, XcmV3WeightLimit, 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 * After the end of `PendingInterval` this sum becomes completely114 * free for further use.115 **/116 unstakeAll: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;117 /**118 * Unstakes the amount of balance for the staker.119 * After the end of `PendingInterval` this sum becomes completely120 * free for further use.121 * 122 * # Arguments123 * 124 * * `staker`: staker account.125 * * `amount`: amount of unstaked funds.126 **/127 unstakePartial: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;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 * ## Complexity138 * - Same as transfer, but additional read and write because the source account is not139 * assumed to be in the overlay.140 **/141 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>]>;142 /**143 * Unreserve some balance from a user by force.144 * 145 * Can only be called by ROOT.146 **/147 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;148 /**149 * Set the balances of a given account.150 * 151 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will152 * also alter the total issuance of the system (`TotalIssuance`) appropriately.153 * If the new free or reserved balance is below the existential deposit,154 * it will reset the account nonce (`frame_system::AccountNonce`).155 * 156 * The dispatch origin for this call is `root`.157 **/158 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>]>;159 /**160 * Transfer some liquid free balance to another account.161 * 162 * `transfer` will set the `FreeBalance` of the sender and receiver.163 * If the sender's account is below the existential deposit as a result164 * of the transfer, the account will be reaped.165 * 166 * The dispatch origin for this call must be `Signed` by the transactor.167 * 168 * ## Complexity169 * - Dependent on arguments but not critical, given proper implementations for input config170 * types. See related functions below.171 * - It contains a limited number of reads and writes internally and no complex172 * computation.173 * 174 * Related functions:175 * 176 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.177 * - Transferring balances to accounts that did not exist before will cause178 * `T::OnNewAccount::on_new_account` to be called.179 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.180 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check181 * that the transfer will not kill the origin account.182 **/183 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>]>;184 /**185 * Transfer the entire transferable balance from the caller account.186 * 187 * NOTE: This function only attempts to transfer _transferable_ balances. This means that188 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be189 * transferred by this function. To ensure that this function results in a killed account,190 * you might need to prepare the account by removing any reference counters, storage191 * deposits, etc...192 * 193 * The dispatch origin of this call must be Signed.194 * 195 * - `dest`: The recipient of the transfer.196 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all197 * of the funds the account has, causing the sender account to be killed (false), or198 * transfer everything except at least the existential deposit, which will guarantee to199 * keep the sender account alive (true). ## Complexity200 * - O(1). Just like transfer, but reading the user's transferable balance first.201 **/202 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;203 /**204 * Same as the [`transfer`] call, but with a check that the transfer will not kill the205 * origin account.206 * 207 * 99% of the time you want [`transfer`] instead.208 * 209 * [`transfer`]: struct.Pallet.html#method.transfer210 **/211 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>]>;212 /**213 * Generic tx214 **/215 [key: string]: SubmittableExtrinsicFunction<ApiType>;216 };217 charging: {218 /**219 * Generic tx220 **/221 [key: string]: SubmittableExtrinsicFunction<ApiType>;222 };223 collatorSelection: {224 /**225 * Add a collator to the list of invulnerable (fixed) collators.226 **/227 addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;228 /**229 * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.230 * Note that the collator can only leave on session change.231 * The `LicenseBond` will be unreserved and returned immediately.232 * 233 * This call is, of course, not applicable to `Invulnerable` collators.234 **/235 forceReleaseLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;236 /**237 * Purchase a license on block collation for this account.238 * It does not make it a collator candidate, use `onboard` afterward. The account must239 * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.240 * 241 * This call is not available to `Invulnerable` collators.242 **/243 getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;244 /**245 * Deregister `origin` as a collator candidate. Note that the collator can only leave on246 * session change. The license to `onboard` later at any other time will remain.247 **/248 offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;249 /**250 * Register this account as a candidate for collators for next sessions.251 * The account must already hold a license, and cannot offboard immediately during a session.252 * 253 * This call is not available to `Invulnerable` collators.254 **/255 onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;256 /**257 * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.258 * 259 * This call is not available to `Invulnerable` collators.260 **/261 releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;262 /**263 * Remove a collator from the list of invulnerable (fixed) collators.264 **/265 removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;266 /**267 * Generic tx268 **/269 [key: string]: SubmittableExtrinsicFunction<ApiType>;270 };271 configuration: {272 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;273 setCollatorSelectionDesiredCollators: AugmentedSubmittable<(max: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;274 setCollatorSelectionKickThreshold: AugmentedSubmittable<(threshold: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;275 setCollatorSelectionLicenseBond: AugmentedSubmittable<(amount: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u128>]>;276 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;277 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;278 /**279 * Generic tx280 **/281 [key: string]: SubmittableExtrinsicFunction<ApiType>;282 };283 cumulusXcm: {284 /**285 * Generic tx286 **/287 [key: string]: SubmittableExtrinsicFunction<ApiType>;288 };289 dmpQueue: {290 /**291 * Service a single overweight message.292 **/293 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;294 /**295 * Generic tx296 **/297 [key: string]: SubmittableExtrinsicFunction<ApiType>;298 };299 ethereum: {300 /**301 * Transact an Ethereum transaction.302 **/303 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;304 /**305 * Generic tx306 **/307 [key: string]: SubmittableExtrinsicFunction<ApiType>;308 };309 evm: {310 /**311 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.312 **/313 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>]>>]>;314 /**315 * Issue an EVM create operation. This is similar to a contract creation transaction in316 * Ethereum.317 **/318 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>]>>]>;319 /**320 * Issue an EVM create2 operation.321 **/322 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>]>>]>;323 /**324 * Withdraw balance from EVM into currency/balances pallet.325 **/326 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;327 /**328 * Generic tx329 **/330 [key: string]: SubmittableExtrinsicFunction<ApiType>;331 };332 evmCoderSubstrate: {333 emptyCall: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;334 /**335 * Generic tx336 **/337 [key: string]: SubmittableExtrinsicFunction<ApiType>;338 };339 evmContractHelpers: {340 /**341 * Migrate contract to use `SponsoringMode` storage instead of `SelfSponsoring`342 **/343 migrateFromSelfSponsoring: AugmentedSubmittable<(addresses: Vec<H160> | (H160 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<H160>]>;344 /**345 * Generic tx346 **/347 [key: string]: SubmittableExtrinsicFunction<ApiType>;348 };349 evmMigration: {350 /**351 * Start contract migration, inserts contract stub at target address,352 * and marks account as pending, allowing to insert storage353 **/354 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;355 /**356 * Finish contract migration, allows it to be called.357 * It is not possible to alter contract storage via [`Self::set_data`]358 * after this call.359 **/360 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;361 /**362 * Create ethereum events attached to the fake transaction363 **/364 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;365 /**366 * Create substrate events367 **/368 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;369 /**370 * Remove remark compatibility data leftovers371 **/372 removeRmrkData: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;373 /**374 * Insert items into contract storage, this method can be called375 * multiple times376 **/377 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;378 /**379 * Generic tx380 **/381 [key: string]: SubmittableExtrinsicFunction<ApiType>;382 };383 foreignAssets: {384 registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;385 updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;386 /**387 * Generic tx388 **/389 [key: string]: SubmittableExtrinsicFunction<ApiType>;390 };391 identity: {392 /**393 * Add a registrar to the system.394 * 395 * The dispatch origin for this call must be `T::RegistrarOrigin`.396 * 397 * - `account`: the account of the registrar.398 * 399 * Emits `RegistrarAdded` if successful.400 * 401 * # <weight>402 * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).403 * - One storage mutation (codec `O(R)`).404 * - One event.405 * # </weight>406 **/407 addRegistrar: AugmentedSubmittable<(account: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;408 /**409 * Add the given account to the sender's subs.410 * 411 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated412 * to the sender.413 * 414 * The dispatch origin for this call must be _Signed_ and the sender must have a registered415 * sub identity of `sub`.416 **/417 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]>;418 /**419 * Cancel a previous request.420 * 421 * Payment: A previously reserved deposit is returned on success.422 * 423 * The dispatch origin for this call must be _Signed_ and the sender must have a424 * registered identity.425 * 426 * - `reg_index`: The index of the registrar whose judgement is no longer requested.427 * 428 * Emits `JudgementUnrequested` if successful.429 * 430 * # <weight>431 * - `O(R + X)`.432 * - One balance-reserve operation.433 * - One storage mutation `O(R + X)`.434 * - One event435 * # </weight>436 **/437 cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;438 /**439 * Clear an account's identity info and all sub-accounts and return all deposits.440 * 441 * Payment: All reserved balances on the account are returned.442 * 443 * The dispatch origin for this call must be _Signed_ and the sender must have a registered444 * identity.445 * 446 * Emits `IdentityCleared` if successful.447 * 448 * # <weight>449 * - `O(R + S + X)`450 * - where `R` registrar-count (governance-bounded).451 * - where `S` subs-count (hard- and deposit-bounded).452 * - where `X` additional-field-count (deposit-bounded and code-bounded).453 * - One balance-unreserve operation.454 * - `2` storage reads and `S + 2` storage deletions.455 * - One event.456 * # </weight>457 **/458 clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;459 /**460 * Set identities to be associated with the provided accounts as force origin.461 * 462 * This is not meant to operate in tandem with the identity pallet as is,463 * and be instead used to keep identities made and verified externally,464 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.465 **/466 forceInsertIdentities: AugmentedSubmittable<(identities: Vec<ITuple<[AccountId32, PalletIdentityRegistration]>> | ([AccountId32 | string | Uint8Array, PalletIdentityRegistration | { judgements?: any; deposit?: any; info?: any } | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId32, PalletIdentityRegistration]>>]>;467 /**468 * Remove identities associated with the provided accounts as force origin.469 * 470 * This is not meant to operate in tandem with the identity pallet as is,471 * and be instead used to keep identities made and verified externally,472 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.473 **/474 forceRemoveIdentities: AugmentedSubmittable<(identities: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;475 /**476 * Set sub-identities to be associated with the provided accounts as force origin.477 * 478 * This is not meant to operate in tandem with the identity pallet as is,479 * and be instead used to keep identities made and verified externally,480 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.481 **/482 forceSetSubs: AugmentedSubmittable<(subs: Vec<ITuple<[AccountId32, ITuple<[u128, Vec<ITuple<[AccountId32, Data]>>]>]>> | ([AccountId32 | string | Uint8Array, ITuple<[u128, Vec<ITuple<[AccountId32, Data]>>]> | [u128 | AnyNumber | Uint8Array, 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, ITuple<[u128, Vec<ITuple<[AccountId32, Data]>>]>]>>]>;483 /**484 * Remove an account's identity and sub-account information and slash the deposits.485 * 486 * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by487 * `Slash`. Verification request deposits are not returned; they should be cancelled488 * manually using `cancel_request`.489 * 490 * The dispatch origin for this call must match `T::ForceOrigin`.491 * 492 * - `target`: the account whose identity the judgement is upon. This must be an account493 * with a registered identity.494 * 495 * Emits `IdentityKilled` if successful.496 * 497 * # <weight>498 * - `O(R + S + X)`.499 * - One balance-reserve operation.500 * - `S + 2` storage mutations.501 * - One event.502 * # </weight>503 **/504 killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;505 /**506 * Provide a judgement for an account's identity.507 * 508 * The dispatch origin for this call must be _Signed_ and the sender must be the account509 * of the registrar whose index is `reg_index`.510 * 511 * - `reg_index`: the index of the registrar whose judgement is being made.512 * - `target`: the account whose identity the judgement is upon. This must be an account513 * with a registered identity.514 * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.515 * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.516 * 517 * Emits `JudgementGiven` if successful.518 * 519 * # <weight>520 * - `O(R + X)`.521 * - One balance-transfer operation.522 * - Up to one account-lookup operation.523 * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.524 * - One event.525 * # </weight>526 **/527 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]>;528 /**529 * Remove the sender as a sub-account.530 * 531 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated532 * to the sender (*not* the original depositor).533 * 534 * The dispatch origin for this call must be _Signed_ and the sender must have a registered535 * super-identity.536 * 537 * NOTE: This should not normally be used, but is provided in the case that the non-538 * controller of an account is maliciously registered as a sub-account.539 **/540 quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;541 /**542 * Remove the given account from the sender's subs.543 * 544 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated545 * to the sender.546 * 547 * The dispatch origin for this call must be _Signed_ and the sender must have a registered548 * sub identity of `sub`.549 **/550 removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;551 /**552 * Alter the associated name of the given sub-account.553 * 554 * The dispatch origin for this call must be _Signed_ and the sender must have a registered555 * sub identity of `sub`.556 **/557 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]>;558 /**559 * Request a judgement from a registrar.560 * 561 * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement562 * given.563 * 564 * The dispatch origin for this call must be _Signed_ and the sender must have a565 * registered identity.566 * 567 * - `reg_index`: The index of the registrar whose judgement is requested.568 * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:569 * 570 * ```nocompile571 * Self::registrars().get(reg_index).unwrap().fee572 * ```573 * 574 * Emits `JudgementRequested` if successful.575 * 576 * # <weight>577 * - `O(R + X)`.578 * - One balance-reserve operation.579 * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.580 * - One event.581 * # </weight>582 **/583 requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;584 /**585 * Change the account associated with a registrar.586 * 587 * The dispatch origin for this call must be _Signed_ and the sender must be the account588 * of the registrar whose index is `index`.589 * 590 * - `index`: the index of the registrar whose fee is to be set.591 * - `new`: the new account ID.592 * 593 * # <weight>594 * - `O(R)`.595 * - One storage mutation `O(R)`.596 * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)597 * # </weight>598 **/599 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]>;600 /**601 * Set the fee required for a judgement to be requested from a registrar.602 * 603 * The dispatch origin for this call must be _Signed_ and the sender must be the account604 * of the registrar whose index is `index`.605 * 606 * - `index`: the index of the registrar whose fee is to be set.607 * - `fee`: the new fee.608 * 609 * # <weight>610 * - `O(R)`.611 * - One storage mutation `O(R)`.612 * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)613 * # </weight>614 **/615 setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;616 /**617 * Set the field information for a registrar.618 * 619 * The dispatch origin for this call must be _Signed_ and the sender must be the account620 * of the registrar whose index is `index`.621 * 622 * - `index`: the index of the registrar whose fee is to be set.623 * - `fields`: the fields that the registrar concerns themselves with.624 * 625 * # <weight>626 * - `O(R)`.627 * - One storage mutation `O(R)`.628 * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)629 * # </weight>630 **/631 setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;632 /**633 * Set an account's identity information and reserve the appropriate deposit.634 * 635 * If the account already has identity information, the deposit is taken as part payment636 * for the new deposit.637 * 638 * The dispatch origin for this call must be _Signed_.639 * 640 * - `info`: The identity information.641 * 642 * Emits `IdentitySet` if successful.643 * 644 * # <weight>645 * - `O(X + X' + R)`646 * - where `X` additional-field-count (deposit-bounded and code-bounded)647 * - where `R` judgements-count (registrar-count-bounded)648 * - One balance reserve operation.649 * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).650 * - One event.651 * # </weight>652 **/653 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]>;654 /**655 * Set the sub-accounts of the sender.656 * 657 * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned658 * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.659 * 660 * The dispatch origin for this call must be _Signed_ and the sender must have a registered661 * identity.662 * 663 * - `subs`: The identity's (new) sub-accounts.664 * 665 * # <weight>666 * - `O(P + S)`667 * - where `P` old-subs-count (hard- and deposit-bounded).668 * - where `S` subs-count (hard- and deposit-bounded).669 * - At most one balance operations.670 * - DB:671 * - `P + S` storage mutations (codec complexity `O(1)`)672 * - One storage read (codec complexity `O(P)`).673 * - One storage write (codec complexity `O(S)`).674 * - One storage-exists (`IdentityOf::contains_key`).675 * # </weight>676 **/677 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]>>]>;678 /**679 * Generic tx680 **/681 [key: string]: SubmittableExtrinsicFunction<ApiType>;682 };683 inflation: {684 /**685 * This method sets the inflation start date. Can be only called once.686 * Inflation start block can be backdated and will catch up. The method will create Treasury687 * account if it does not exist and perform the first inflation deposit.688 * 689 * # Permissions690 * 691 * * Root692 * 693 * # Arguments694 * 695 * * inflation_start_relay_block: The relay chain block at which inflation should start696 **/697 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;698 /**699 * Generic tx700 **/701 [key: string]: SubmittableExtrinsicFunction<ApiType>;702 };703 maintenance: {704 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;705 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;706 /**707 * Execute a runtime call stored as a preimage.708 * 709 * `weight_bound` is the maximum weight that the caller is willing710 * to allow the extrinsic to be executed with.711 **/712 executePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array, weightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, SpWeightsWeightV2Weight]>;713 /**714 * Generic tx715 **/716 [key: string]: SubmittableExtrinsicFunction<ApiType>;717 };718 parachainInfo: {719 /**720 * Generic tx721 **/722 [key: string]: SubmittableExtrinsicFunction<ApiType>;723 };724 parachainSystem: {725 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;726 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;727 /**728 * Set the current validation data.729 * 730 * This should be invoked exactly once per block. It will panic at the finalization731 * phase if the call was not invoked.732 * 733 * The dispatch origin for this call must be `Inherent`734 * 735 * As a side effect, this function upgrades the current validation function736 * if the appropriate time has come.737 **/738 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;739 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;740 /**741 * Generic tx742 **/743 [key: string]: SubmittableExtrinsicFunction<ApiType>;744 };745 polkadotXcm: {746 /**747 * Execute an XCM message from a local, signed, origin.748 * 749 * An event is deposited indicating whether `msg` could be executed completely or only750 * partially.751 * 752 * No more than `max_weight` will be used in its attempted execution. If this is less than the753 * maximum amount of weight that the message could take to be executed, then no execution754 * attempt will be made.755 * 756 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully757 * to completion; only that *some* of it was executed.758 **/759 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, SpWeightsWeightV2Weight]>;760 /**761 * Set a safe XCM version (the version that XCM should be encoded with if the most recent762 * version a destination can accept is unknown).763 * 764 * - `origin`: Must be Root.765 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.766 **/767 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;768 /**769 * Ask a location to notify us regarding their XCM version and any changes to it.770 * 771 * - `origin`: Must be Root.772 * - `location`: The location to which we should subscribe for XCM version notifications.773 **/774 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;775 /**776 * Require that a particular destination should no longer notify us regarding any XCM777 * version changes.778 * 779 * - `origin`: Must be Root.780 * - `location`: The location to which we are currently subscribed for XCM version781 * notifications which we no longer desire.782 **/783 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;784 /**785 * Extoll that a particular destination can be communicated with through a particular786 * version of XCM.787 * 788 * - `origin`: Must be Root.789 * - `location`: The destination that is being described.790 * - `xcm_version`: The latest version of XCM that `location` supports.791 **/792 forceXcmVersion: AugmentedSubmittable<(location: XcmV3MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV3MultiLocation, u32]>;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`, up to enough to pay for `weight_limit` of weight. If more weight799 * is needed than `weight_limit`, then the operation will fail and the assets send may be800 * at risk.801 * 802 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.803 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send804 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.805 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be806 * an `AccountId32` value.807 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the808 * `dest` side.809 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay810 * fees.811 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.812 **/813 limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV3WeightLimit]>;814 /**815 * Teleport some assets from the local chain to some destination chain.816 * 817 * Fee payment on the destination side is made from the asset in the `assets` vector of818 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight819 * is needed than `weight_limit`, then the operation will fail and the assets send may be820 * at risk.821 * 822 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.823 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send824 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.825 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be826 * an `AccountId32` value.827 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the828 * `dest` side. May not be empty.829 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay830 * fees.831 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.832 **/833 limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV3WeightLimit]>;834 /**835 * Transfer some assets from the local chain to the sovereign account of a destination836 * chain and forward a notification XCM.837 * 838 * Fee payment on the destination side is made from the asset in the `assets` vector of839 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,840 * with all fees taken as needed from the asset.841 * 842 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.843 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send844 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.845 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be846 * an `AccountId32` value.847 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the848 * `dest` side.849 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay850 * fees.851 **/852 reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;853 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;854 /**855 * Teleport some assets from the local chain to some destination chain.856 * 857 * Fee payment on the destination side is made from the asset in the `assets` vector of858 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,859 * with all fees taken as needed from the asset.860 * 861 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.862 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send863 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.864 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be865 * an `AccountId32` value.866 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the867 * `dest` side. May not be empty.868 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay869 * fees.870 **/871 teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;872 /**873 * Generic tx874 **/875 [key: string]: SubmittableExtrinsicFunction<ApiType>;876 };877 preimage: {878 /**879 * Register a preimage on-chain.880 * 881 * If the preimage was previously requested, no fees or deposits are taken for providing882 * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.883 **/884 notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;885 /**886 * Request a preimage be uploaded to the chain without paying any fees or deposits.887 * 888 * If the preimage requests has already been provided on-chain, we unreserve any deposit889 * a user may have paid, and take the control of the preimage out of their hands.890 **/891 requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;892 /**893 * Clear an unrequested preimage from the runtime storage.894 * 895 * If `len` is provided, then it will be a much cheaper operation.896 * 897 * - `hash`: The hash of the preimage to be removed from the store.898 * - `len`: The length of the preimage of `hash`.899 **/900 unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;901 /**902 * Clear a previously made request for a preimage.903 * 904 * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.905 **/906 unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;907 /**908 * Generic tx909 **/910 [key: string]: SubmittableExtrinsicFunction<ApiType>;911 };912 session: {913 /**914 * Removes any session key(s) of the function caller.915 * 916 * This doesn't take effect until the next session.917 * 918 * The dispatch origin of this function must be Signed and the account must be either be919 * convertible to a validator ID using the chain's typical addressing system (this usually920 * means being a controller account) or directly convertible into a validator ID (which921 * usually means being a stash account).922 * 923 * ## Complexity924 * - `O(1)` in number of key types. Actual cost depends on the number of length of925 * `T::Keys::key_ids()` which is fixed.926 **/927 purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;928 /**929 * Sets the session key(s) of the function caller to `keys`.930 * Allows an account to set its session key prior to becoming a validator.931 * This doesn't take effect until the next session.932 * 933 * The dispatch origin of this function must be signed.934 * 935 * ## Complexity936 * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is937 * fixed.938 **/939 setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;940 /**941 * Generic tx942 **/943 [key: string]: SubmittableExtrinsicFunction<ApiType>;944 };945 structure: {946 /**947 * Generic tx948 **/949 [key: string]: SubmittableExtrinsicFunction<ApiType>;950 };951 sudo: {952 /**953 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo954 * key.955 * 956 * The dispatch origin for this call must be _Signed_.957 * 958 * ## Complexity959 * - O(1).960 **/961 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;962 /**963 * Authenticates the sudo key and dispatches a function call with `Root` origin.964 * 965 * The dispatch origin for this call must be _Signed_.966 * 967 * ## Complexity968 * - O(1).969 **/970 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;971 /**972 * Authenticates the sudo key and dispatches a function call with `Signed` origin from973 * a given account.974 * 975 * The dispatch origin for this call must be _Signed_.976 * 977 * ## Complexity978 * - O(1).979 **/980 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]>;981 /**982 * Authenticates the sudo key and dispatches a function call with `Root` origin.983 * This function does not check the weight of the call, and instead allows the984 * Sudo user to specify the weight of the call.985 * 986 * The dispatch origin for this call must be _Signed_.987 * 988 * ## Complexity989 * - O(1).990 **/991 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;992 /**993 * Generic tx994 **/995 [key: string]: SubmittableExtrinsicFunction<ApiType>;996 };997 system: {998 /**999 * Kill all storage items with a key that starts with the given prefix.1000 * 1001 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1002 * the prefix we are removing to accurately calculate the weight of this function.1003 **/1004 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1005 /**1006 * Kill some items from storage.1007 **/1008 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1009 /**1010 * Make some on-chain remark.1011 * 1012 * ## Complexity1013 * - `O(1)`1014 **/1015 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1016 /**1017 * Make some on-chain remark and emit event.1018 **/1019 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1020 /**1021 * Set the new runtime code.1022 * 1023 * ## Complexity1024 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`1025 **/1026 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1027 /**1028 * Set the new runtime code without doing any checks of the given `code`.1029 * 1030 * ## Complexity1031 * - `O(C)` where `C` length of `code`1032 **/1033 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1034 /**1035 * Set the number of pages in the WebAssembly environment's heap.1036 **/1037 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1038 /**1039 * Set some items of storage.1040 **/1041 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1042 /**1043 * Generic tx1044 **/1045 [key: string]: SubmittableExtrinsicFunction<ApiType>;1046 };1047 testUtils: {1048 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1049 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1050 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1051 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1052 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1053 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1054 /**1055 * Generic tx1056 **/1057 [key: string]: SubmittableExtrinsicFunction<ApiType>;1058 };1059 timestamp: {1060 /**1061 * Set the current time.1062 * 1063 * This call should be invoked exactly once per block. It will panic at the finalization1064 * phase, if this call hasn't been invoked by that time.1065 * 1066 * The timestamp should be greater than the previous one by the amount specified by1067 * `MinimumPeriod`.1068 * 1069 * The dispatch origin for this call must be `Inherent`.1070 * 1071 * ## Complexity1072 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1073 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1074 * `on_finalize`)1075 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1076 **/1077 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1078 /**1079 * Generic tx1080 **/1081 [key: string]: SubmittableExtrinsicFunction<ApiType>;1082 };1083 tokens: {1084 /**1085 * Exactly as `transfer`, except the origin must be root and the source1086 * account may be specified.1087 * 1088 * The dispatch origin for this call must be _Root_.1089 * 1090 * - `source`: The sender of the transfer.1091 * - `dest`: The recipient of the transfer.1092 * - `currency_id`: currency type.1093 * - `amount`: free balance amount to tranfer.1094 **/1095 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>]>;1096 /**1097 * Set the balances of a given account.1098 * 1099 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1100 * will also decrease the total issuance of the system1101 * (`TotalIssuance`). If the new free or reserved balance is below the1102 * existential deposit, it will reap the `AccountInfo`.1103 * 1104 * The dispatch origin for this call is `root`.1105 **/1106 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>]>;1107 /**1108 * Transfer some liquid free balance to another account.1109 * 1110 * `transfer` will set the `FreeBalance` of the sender and receiver.1111 * It will decrease the total issuance of the system by the1112 * `TransferFee`. If the sender's account is below the existential1113 * deposit as a result of the transfer, the account will be reaped.1114 * 1115 * The dispatch origin for this call must be `Signed` by the1116 * transactor.1117 * 1118 * - `dest`: The recipient of the transfer.1119 * - `currency_id`: currency type.1120 * - `amount`: free balance amount to tranfer.1121 **/1122 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>]>;1123 /**1124 * Transfer all remaining balance to the given account.1125 * 1126 * NOTE: This function only attempts to transfer _transferable_1127 * balances. This means that any locked, reserved, or existential1128 * deposits (when `keep_alive` is `true`), will not be transferred by1129 * this function. To ensure that this function results in a killed1130 * account, you might need to prepare the account by removing any1131 * reference counters, storage deposits, etc...1132 * 1133 * The dispatch origin for this call must be `Signed` by the1134 * transactor.1135 * 1136 * - `dest`: The recipient of the transfer.1137 * - `currency_id`: currency type.1138 * - `keep_alive`: A boolean to determine if the `transfer_all`1139 * operation should send all of the funds the account has, causing1140 * the sender account to be killed (false), or transfer everything1141 * except at least the existential deposit, which will guarantee to1142 * keep the sender account alive (true).1143 **/1144 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]>;1145 /**1146 * Same as the [`transfer`] call, but with a check that the transfer1147 * will not kill the origin account.1148 * 1149 * 99% of the time you want [`transfer`] instead.1150 * 1151 * The dispatch origin for this call must be `Signed` by the1152 * transactor.1153 * 1154 * - `dest`: The recipient of the transfer.1155 * - `currency_id`: currency type.1156 * - `amount`: free balance amount to tranfer.1157 **/1158 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>]>;1159 /**1160 * Generic tx1161 **/1162 [key: string]: SubmittableExtrinsicFunction<ApiType>;1163 };1164 treasury: {1165 /**1166 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1167 * and the original deposit will be returned.1168 * 1169 * May only be called from `T::ApproveOrigin`.1170 * 1171 * ## Complexity1172 * - O(1).1173 **/1174 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1175 /**1176 * Put forward a suggestion for spending. A deposit proportional to the value1177 * is reserved and slashed if the proposal is rejected. It is returned once the1178 * proposal is awarded.1179 * 1180 * ## Complexity1181 * - O(1)1182 **/1183 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]>;1184 /**1185 * Reject a proposed spend. The original deposit will be slashed.1186 * 1187 * May only be called from `T::RejectOrigin`.1188 * 1189 * ## Complexity1190 * - O(1)1191 **/1192 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1193 /**1194 * Force a previously approved proposal to be removed from the approval queue.1195 * The original deposit will no longer be returned.1196 * 1197 * May only be called from `T::RejectOrigin`.1198 * - `proposal_id`: The index of a proposal1199 * 1200 * ## Complexity1201 * - O(A) where `A` is the number of approvals1202 * 1203 * Errors:1204 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1205 * i.e., the proposal has not been approved. This could also mean the proposal does not1206 * exist altogether, thus there is no way it would have been approved in the first place.1207 **/1208 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1209 /**1210 * Propose and approve a spend of treasury funds.1211 * 1212 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1213 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1214 * - `beneficiary`: The destination account for the transfer.1215 * 1216 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1217 * beneficiary.1218 **/1219 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]>;1220 /**1221 * Generic tx1222 **/1223 [key: string]: SubmittableExtrinsicFunction<ApiType>;1224 };1225 unique: {1226 /**1227 * Add an admin to a collection.1228 * 1229 * NFT Collection can be controlled by multiple admin addresses1230 * (some which can also be servers, for example). Admins can issue1231 * and burn NFTs, as well as add and remove other admins,1232 * but cannot change NFT or Collection ownership.1233 * 1234 * # Permissions1235 * 1236 * * Collection owner1237 * * Collection admin1238 * 1239 * # Arguments1240 * 1241 * * `collection_id`: ID of the Collection to add an admin for.1242 * * `new_admin`: Address of new admin to add.1243 **/1244 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1245 /**1246 * Add an address to allow list.1247 * 1248 * # Permissions1249 * 1250 * * Collection owner1251 * * Collection admin1252 * 1253 * # Arguments1254 * 1255 * * `collection_id`: ID of the modified collection.1256 * * `address`: ID of the address to be added to the allowlist.1257 **/1258 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1259 /**1260 * Allow a non-permissioned address to transfer or burn an item.1261 * 1262 * # Permissions1263 * 1264 * * Collection owner1265 * * Collection admin1266 * * Current item owner1267 * 1268 * # Arguments1269 * 1270 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1271 * * `collection_id`: ID of the collection the item belongs to.1272 * * `item_id`: ID of the item transactions on which are now approved.1273 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1274 * Set to 0 to revoke the approval.1275 **/1276 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]>;1277 /**1278 * Allow a non-permissioned address to transfer or burn an item from owner's eth mirror.1279 * 1280 * # Permissions1281 * 1282 * * Collection owner1283 * * Collection admin1284 * * Current item owner1285 * 1286 * # Arguments1287 * 1288 * * `from`: Owner's account eth mirror1289 * * `to`: Account to be approved to make specific transactions on non-owned tokens.1290 * * `collection_id`: ID of the collection the item belongs to.1291 * * `item_id`: ID of the item transactions on which are now approved.1292 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1293 * Set to 0 to revoke the approval.1294 **/1295 approveFrom: AugmentedSubmittable<(from: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, to: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>;1296 /**1297 * Destroy a token on behalf of the owner as a non-owner account.1298 * 1299 * See also: [`approve`][`Pallet::approve`].1300 * 1301 * After this method executes, one approval is removed from the total so that1302 * the approved address will not be able to transfer this item again from this owner.1303 * 1304 * # Permissions1305 * 1306 * * Collection owner1307 * * Collection admin1308 * * Current token owner1309 * * Address approved by current item owner1310 * 1311 * # Arguments1312 * 1313 * * `from`: The owner of the burning item.1314 * * `collection_id`: ID of the collection to which the item belongs.1315 * * `item_id`: ID of item to burn.1316 * * `value`: Number of pieces to burn.1317 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1318 * * Fungible Mode: The desired number of pieces to burn.1319 * * Re-Fungible Mode: The desired number of pieces to burn.1320 **/1321 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]>;1322 /**1323 * Destroy an item.1324 * 1325 * # Permissions1326 * 1327 * * Collection owner1328 * * Collection admin1329 * * Current item owner1330 * 1331 * # Arguments1332 * 1333 * * `collection_id`: ID of the collection to which the item belongs.1334 * * `item_id`: ID of item to burn.1335 * * `value`: Number of pieces of the item to destroy.1336 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1337 * * Fungible Mode: The desired number of pieces to burn.1338 * * Re-Fungible Mode: The desired number of pieces to burn.1339 **/1340 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1341 /**1342 * Change the owner of the collection.1343 * 1344 * # Permissions1345 * 1346 * * Collection owner1347 * 1348 * # Arguments1349 * 1350 * * `collection_id`: ID of the modified collection.1351 * * `new_owner`: ID of the account that will become the owner.1352 **/1353 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1354 /**1355 * Confirm own sponsorship of a collection, becoming the sponsor.1356 * 1357 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1358 * Sponsor can pay the fees of a transaction instead of the sender,1359 * but only within specified limits.1360 * 1361 * # Permissions1362 * 1363 * * Sponsor-to-be1364 * 1365 * # Arguments1366 * 1367 * * `collection_id`: ID of the collection with the pending sponsor.1368 **/1369 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1370 /**1371 * Create a collection of tokens.1372 * 1373 * Each Token may have multiple properties encoded as an array of bytes1374 * of certain length. The initial owner of the collection is set1375 * to the address that signed the transaction and can be changed later.1376 * 1377 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1378 * 1379 * # Permissions1380 * 1381 * * Anyone - becomes the owner of the new collection.1382 * 1383 * # Arguments1384 * 1385 * * `collection_name`: Wide-character string with collection name1386 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1387 * * `collection_description`: Wide-character string with collection description1388 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1389 * * `token_prefix`: Byte string containing the token prefix to mark a collection1390 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1391 * * `mode`: Type of items stored in the collection and type dependent data.1392 * 1393 * returns collection ID1394 * 1395 * Deprecated: `create_collection_ex` is more up-to-date and advanced, prefer it instead.1396 **/1397 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]>;1398 /**1399 * Create a collection with explicit parameters.1400 * 1401 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1402 * 1403 * # Permissions1404 * 1405 * * Anyone - becomes the owner of the new collection.1406 * 1407 * # Arguments1408 * 1409 * * `data`: Explicit data of a collection used for its creation.1410 **/1411 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]>;1412 /**1413 * Mint an item within a collection.1414 * 1415 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1416 * 1417 * # Permissions1418 * 1419 * * Collection owner1420 * * Collection admin1421 * * Anyone if1422 * * Allow List is enabled, and1423 * * Address is added to allow list, and1424 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1425 * 1426 * # Arguments1427 * 1428 * * `collection_id`: ID of the collection to which an item would belong.1429 * * `owner`: Address of the initial owner of the item.1430 * * `data`: Token data describing the item to store on chain.1431 **/1432 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]>;1433 /**1434 * Create multiple items within a collection.1435 * 1436 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1437 * 1438 * # Permissions1439 * 1440 * * Collection owner1441 * * Collection admin1442 * * Anyone if1443 * * Allow List is enabled, and1444 * * Address is added to the allow list, and1445 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1446 * 1447 * # Arguments1448 * 1449 * * `collection_id`: ID of the collection to which the tokens would belong.1450 * * `owner`: Address of the initial owner of the tokens.1451 * * `items_data`: Vector of data describing each item to be created.1452 **/1453 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>]>;1454 /**1455 * Create multiple items within a collection with explicitly specified initial parameters.1456 * 1457 * # Permissions1458 * 1459 * * Collection owner1460 * * Collection admin1461 * * Anyone if1462 * * Allow List is enabled, and1463 * * Address is added to allow list, and1464 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1465 * 1466 * # Arguments1467 * 1468 * * `collection_id`: ID of the collection to which the tokens would belong.1469 * * `data`: Explicit item creation data.1470 **/1471 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1472 /**1473 * Delete specified collection properties.1474 * 1475 * # Permissions1476 * 1477 * * Collection Owner1478 * * Collection Admin1479 * 1480 * # Arguments1481 * 1482 * * `collection_id`: ID of the modified collection.1483 * * `property_keys`: Vector of keys of the properties to be deleted.1484 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1485 **/1486 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1487 /**1488 * Delete specified token properties. Currently properties only work with NFTs.1489 * 1490 * # Permissions1491 * 1492 * * Depends on collection's token property permissions and specified property mutability:1493 * * Collection owner1494 * * Collection admin1495 * * Token owner1496 * 1497 * # Arguments1498 * 1499 * * `collection_id`: ID of the collection to which the token belongs.1500 * * `token_id`: ID of the modified token.1501 * * `property_keys`: Vector of keys of the properties to be deleted.1502 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1503 **/1504 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1505 /**1506 * Destroy a collection if no tokens exist within.1507 * 1508 * # Permissions1509 * 1510 * * Collection owner1511 * 1512 * # Arguments1513 * 1514 * * `collection_id`: Collection to destroy.1515 **/1516 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1517 /**1518 * Repairs a collection if the data was somehow corrupted.1519 * 1520 * # Arguments1521 * 1522 * * `collection_id`: ID of the collection to repair.1523 **/1524 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1525 /**1526 * Repairs a token if the data was somehow corrupted.1527 * 1528 * # Arguments1529 * 1530 * * `collection_id`: ID of the collection the item belongs to.1531 * * `item_id`: ID of the item.1532 **/1533 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1534 /**1535 * Remove admin of a collection.1536 * 1537 * An admin address can remove itself. List of admins may become empty,1538 * in which case only Collection Owner will be able to add an Admin.1539 * 1540 * # Permissions1541 * 1542 * * Collection owner1543 * * Collection admin1544 * 1545 * # Arguments1546 * 1547 * * `collection_id`: ID of the collection to remove the admin for.1548 * * `account_id`: Address of the admin to remove.1549 **/1550 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1551 /**1552 * Remove a collection's a sponsor, making everyone pay for their own transactions.1553 * 1554 * # Permissions1555 * 1556 * * Collection owner1557 * 1558 * # Arguments1559 * 1560 * * `collection_id`: ID of the collection with the sponsor to remove.1561 **/1562 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1563 /**1564 * Remove an address from allow list.1565 * 1566 * # Permissions1567 * 1568 * * Collection owner1569 * * Collection admin1570 * 1571 * # Arguments1572 * 1573 * * `collection_id`: ID of the modified collection.1574 * * `address`: ID of the address to be removed from the allowlist.1575 **/1576 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1577 /**1578 * Re-partition a refungible token, while owning all of its parts/pieces.1579 * 1580 * # Permissions1581 * 1582 * * Token owner (must own every part)1583 * 1584 * # Arguments1585 * 1586 * * `collection_id`: ID of the collection the RFT belongs to.1587 * * `token_id`: ID of the RFT.1588 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1589 **/1590 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1591 /**1592 * Sets or unsets the approval of a given operator.1593 * 1594 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1595 * 1596 * # Arguments1597 * 1598 * * `owner`: Token owner1599 * * `operator`: Operator1600 * * `approve`: Should operator status be granted or revoked?1601 **/1602 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1603 /**1604 * Set specific limits of a collection. Empty, or None fields mean chain default.1605 * 1606 * # Permissions1607 * 1608 * * Collection owner1609 * * Collection admin1610 * 1611 * # Arguments1612 * 1613 * * `collection_id`: ID of the modified collection.1614 * * `new_limit`: New limits of the collection. Fields that are not set (None)1615 * will not overwrite the old ones.1616 **/1617 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]>;1618 /**1619 * Set specific permissions of a collection. Empty, or None fields mean chain default.1620 * 1621 * # Permissions1622 * 1623 * * Collection owner1624 * * Collection admin1625 * 1626 * # Arguments1627 * 1628 * * `collection_id`: ID of the modified collection.1629 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1630 * will not overwrite the old ones.1631 **/1632 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1633 /**1634 * Add or change collection properties.1635 * 1636 * # Permissions1637 * 1638 * * Collection owner1639 * * Collection admin1640 * 1641 * # Arguments1642 * 1643 * * `collection_id`: ID of the modified collection.1644 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1645 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1646 **/1647 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1648 /**1649 * Set (invite) a new collection sponsor.1650 * 1651 * If successful, confirmation from the sponsor-to-be will be pending.1652 * 1653 * # Permissions1654 * 1655 * * Collection owner1656 * * Collection admin1657 * 1658 * # Arguments1659 * 1660 * * `collection_id`: ID of the modified collection.1661 * * `new_sponsor`: ID of the account of the sponsor-to-be.1662 **/1663 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1664 /**1665 * Add or change token properties according to collection's permissions.1666 * Currently properties only work with NFTs.1667 * 1668 * # Permissions1669 * 1670 * * Depends on collection's token property permissions and specified property mutability:1671 * * Collection owner1672 * * Collection admin1673 * * Token owner1674 * 1675 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1676 * 1677 * # Arguments1678 * 1679 * * `collection_id: ID of the collection to which the token belongs.1680 * * `token_id`: ID of the modified token.1681 * * `properties`: Vector of key-value pairs stored as the token's metadata.1682 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1683 **/1684 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>]>;1685 /**1686 * Add or change token property permissions of a collection.1687 * 1688 * Without a permission for a particular key, a property with that key1689 * cannot be created in a token.1690 * 1691 * # Permissions1692 * 1693 * * Collection owner1694 * * Collection admin1695 * 1696 * # Arguments1697 * 1698 * * `collection_id`: ID of the modified collection.1699 * * `property_permissions`: Vector of permissions for property keys.1700 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1701 **/1702 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1703 /**1704 * Completely allow or disallow transfers for a particular collection.1705 * 1706 * # Permissions1707 * 1708 * * Collection owner1709 * 1710 * # Arguments1711 * 1712 * * `collection_id`: ID of the collection.1713 * * `value`: New value of the flag, are transfers allowed?1714 **/1715 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1716 /**1717 * Change ownership of the token.1718 * 1719 * # Permissions1720 * 1721 * * Collection owner1722 * * Collection admin1723 * * Current token owner1724 * 1725 * # Arguments1726 * 1727 * * `recipient`: Address of token recipient.1728 * * `collection_id`: ID of the collection the item belongs to.1729 * * `item_id`: ID of the item.1730 * * Non-Fungible Mode: Required.1731 * * Fungible Mode: Ignored.1732 * * Re-Fungible Mode: Required.1733 * 1734 * * `value`: Amount to transfer.1735 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1736 * * Fungible Mode: The desired number of pieces to transfer.1737 * * Re-Fungible Mode: The desired number of pieces to transfer.1738 **/1739 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]>;1740 /**1741 * Change ownership of an item on behalf of the owner as a non-owner account.1742 * 1743 * See the [`approve`][`Pallet::approve`] method for additional information.1744 * 1745 * After this method executes, one approval is removed from the total so that1746 * the approved address will not be able to transfer this item again from this owner.1747 * 1748 * # Permissions1749 * 1750 * * Collection owner1751 * * Collection admin1752 * * Current item owner1753 * * Address approved by current item owner1754 * 1755 * # Arguments1756 * 1757 * * `from`: Address that currently owns the token.1758 * * `recipient`: Address of the new token-owner-to-be.1759 * * `collection_id`: ID of the collection the item.1760 * * `item_id`: ID of the item to be transferred.1761 * * `value`: Amount to transfer.1762 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1763 * * Fungible Mode: The desired number of pieces to transfer.1764 * * Re-Fungible Mode: The desired number of pieces to transfer.1765 **/1766 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]>;1767 /**1768 * Generic tx1769 **/1770 [key: string]: SubmittableExtrinsicFunction<ApiType>;1771 };1772 vesting: {1773 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1774 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1775 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>]>;1776 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]>;1777 /**1778 * Generic tx1779 **/1780 [key: string]: SubmittableExtrinsicFunction<ApiType>;1781 };1782 xcmpQueue: {1783 /**1784 * Resumes all XCM executions for the XCMP queue.1785 * 1786 * Note that this function doesn't change the status of the in/out bound channels.1787 * 1788 * - `origin`: Must pass `ControllerOrigin`.1789 **/1790 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1791 /**1792 * Services a single overweight XCM.1793 * 1794 * - `origin`: Must pass `ExecuteOverweightOrigin`.1795 * - `index`: The index of the overweight XCM to service1796 * - `weight_limit`: The amount of weight that XCM execution may take.1797 * 1798 * Errors:1799 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1800 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1801 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1802 * 1803 * Events:1804 * - `OverweightServiced`: On success.1805 **/1806 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;1807 /**1808 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1809 * 1810 * - `origin`: Must pass `ControllerOrigin`.1811 **/1812 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1813 /**1814 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1815 * messages from the channel.1816 * 1817 * - `origin`: Must pass `Root`.1818 * - `new`: Desired value for `QueueConfigData.drop_threshold`1819 **/1820 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1821 /**1822 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1823 * message sending may recommence after it has been suspended.1824 * 1825 * - `origin`: Must pass `Root`.1826 * - `new`: Desired value for `QueueConfigData.resume_threshold`1827 **/1828 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1829 /**1830 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1831 * suspend their sending.1832 * 1833 * - `origin`: Must pass `Root`.1834 * - `new`: Desired value for `QueueConfigData.suspend_value`1835 **/1836 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1837 /**1838 * Overwrites the amount of remaining weight under which we stop processing messages.1839 * 1840 * - `origin`: Must pass `Root`.1841 * - `new`: Desired value for `QueueConfigData.threshold_weight`1842 **/1843 updateThresholdWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1844 /**1845 * Overwrites the speed to which the available weight approaches the maximum weight.1846 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1847 * 1848 * - `origin`: Must pass `Root`.1849 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1850 **/1851 updateWeightRestrictDecay: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1852 /**1853 * Overwrite the maximum amount of weight any individual message may consume.1854 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1855 * 1856 * - `origin`: Must pass `Root`.1857 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1858 **/1859 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1860 /**1861 * Generic tx1862 **/1863 [key: string]: SubmittableExtrinsicFunction<ApiType>;1864 };1865 xTokens: {1866 /**1867 * Transfer native currencies.1868 * 1869 * `dest_weight_limit` is the weight for XCM execution on the dest1870 * chain, and it would be charged from the transferred assets. If set1871 * below requirements, the execution may fail and assets wouldn't be1872 * received.1873 * 1874 * It's a no-op if any error on local XCM execution or message sending.1875 * Note sending assets out per se doesn't guarantee they would be1876 * received. Receiving depends on if the XCM message could be delivered1877 * by the network, and if the receiving chain would handle1878 * messages correctly.1879 **/1880 transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1881 /**1882 * Transfer `MultiAsset`.1883 * 1884 * `dest_weight_limit` is the weight for XCM execution on the dest1885 * chain, and it would be charged from the transferred assets. If set1886 * below requirements, the execution may fail and assets wouldn't be1887 * received.1888 * 1889 * It's a no-op if any error on local XCM execution or message sending.1890 * Note sending assets out per se doesn't guarantee they would be1891 * received. Receiving depends on if the XCM message could be delivered1892 * by the network, and if the receiving chain would handle1893 * messages correctly.1894 **/1895 transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V2: any } | { V3: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1896 /**1897 * Transfer several `MultiAsset` specifying the item to be used as fee1898 * 1899 * `dest_weight_limit` is the weight for XCM execution on the dest1900 * chain, and it would be charged from the transferred assets. If set1901 * below requirements, the execution may fail and assets wouldn't be1902 * received.1903 * 1904 * `fee_item` is index of the MultiAssets that we want to use for1905 * payment1906 * 1907 * It's a no-op if any error on local XCM execution or message sending.1908 * Note sending assets out per se doesn't guarantee they would be1909 * received. Receiving depends on if the XCM message could be delivered1910 * by the network, and if the receiving chain would handle1911 * messages correctly.1912 **/1913 transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1914 /**1915 * Transfer `MultiAsset` specifying the fee and amount as separate.1916 * 1917 * `dest_weight_limit` is the weight for XCM execution on the dest1918 * chain, and it would be charged from the transferred assets. If set1919 * below requirements, the execution may fail and assets wouldn't be1920 * received.1921 * 1922 * `fee` is the multiasset to be spent to pay for execution in1923 * destination chain. Both fee and amount will be subtracted form the1924 * callers balance For now we only accept fee and asset having the same1925 * `MultiLocation` id.1926 * 1927 * If `fee` is not high enough to cover for the execution costs in the1928 * destination chain, then the assets will be trapped in the1929 * destination chain1930 * 1931 * It's a no-op if any error on local XCM execution or message sending.1932 * Note sending assets out per se doesn't guarantee they would be1933 * received. Receiving depends on if the XCM message could be delivered1934 * by the network, and if the receiving chain would handle1935 * messages correctly.1936 **/1937 transferMultiassetWithFee: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V2: any } | { V3: any } | string | Uint8Array, fee: XcmVersionedMultiAsset | { V2: any } | { V3: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1938 /**1939 * Transfer several currencies specifying the item to be used as fee1940 * 1941 * `dest_weight_limit` is the weight for XCM execution on the dest1942 * chain, and it would be charged from the transferred assets. If set1943 * below requirements, the execution may fail and assets wouldn't be1944 * received.1945 * 1946 * `fee_item` is index of the currencies tuple that we want to use for1947 * payment1948 * 1949 * It's a no-op if any error on local XCM execution or message sending.1950 * Note sending assets out per se doesn't guarantee they would be1951 * received. Receiving depends on if the XCM message could be delivered1952 * by the network, and if the receiving chain would handle1953 * messages correctly.1954 **/1955 transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>> | ([PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1956 /**1957 * Transfer native currencies specifying the fee and amount as1958 * separate.1959 * 1960 * `dest_weight_limit` is the weight for XCM execution on the dest1961 * chain, and it would be charged from the transferred assets. If set1962 * below requirements, the execution may fail and assets wouldn't be1963 * received.1964 * 1965 * `fee` is the amount to be spent to pay for execution in destination1966 * chain. Both fee and amount will be subtracted form the callers1967 * balance.1968 * 1969 * If `fee` is not high enough to cover for the execution costs in the1970 * destination chain, then the assets will be trapped in the1971 * destination chain1972 * 1973 * It's a no-op if any error on local XCM execution or message sending.1974 * Note sending assets out per se doesn't guarantee they would be1975 * received. Receiving depends on if the XCM message could be delivered1976 * by the network, and if the receiving chain would handle1977 * messages correctly.1978 **/1979 transferWithFee: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1980 /**1981 * Generic tx1982 **/1983 [key: string]: SubmittableExtrinsicFunction<ApiType>;1984 };1985 } // AugmentedSubmittables1986} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts107.0 KiBsourcehistory