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 * Set the regular balance of a given account.136 * 137 * The dispatch origin for this call is `root`.138 **/139 forceSetBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;140 /**141 * Exactly as `transfer_allow_death`, except the origin must be root and the source account142 * may be specified.143 **/144 forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, Compact<u128>]>;145 /**146 * Unreserve some balance from a user by force.147 * 148 * Can only be called by ROOT.149 **/150 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;151 /**152 * Set the regular balance of a given account; it also takes a reserved balance but this153 * must be the same as the account's current reserved balance.154 * 155 * The dispatch origin for this call is `root`.156 * 157 * WARNING: This call is DEPRECATED! Use `force_set_balance` instead.158 **/159 setBalanceDeprecated: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, oldReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;160 /**161 * Alias for `transfer_allow_death`, provided only for name-wise compatibility.162 * 163 * WARNING: DEPRECATED! Will be released in approximately 3 months.164 **/165 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>]>;166 /**167 * Transfer the entire transferable balance from the caller account.168 * 169 * NOTE: This function only attempts to transfer _transferable_ balances. This means that170 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be171 * transferred by this function. To ensure that this function results in a killed account,172 * you might need to prepare the account by removing any reference counters, storage173 * deposits, etc...174 * 175 * The dispatch origin of this call must be Signed.176 * 177 * - `dest`: The recipient of the transfer.178 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all179 * of the funds the account has, causing the sender account to be killed (false), or180 * transfer everything except at least the existential deposit, which will guarantee to181 * keep the sender account alive (true).182 **/183 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;184 /**185 * Transfer some liquid free balance to another account.186 * 187 * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver.188 * If the sender's account is below the existential deposit as a result189 * of the transfer, the account will be reaped.190 * 191 * The dispatch origin for this call must be `Signed` by the transactor.192 **/193 transferAllowDeath: 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>]>;194 /**195 * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not196 * kill the origin account.197 * 198 * 99% of the time you want [`transfer_allow_death`] instead.199 * 200 * [`transfer_allow_death`]: struct.Pallet.html#method.transfer201 **/202 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>]>;203 /**204 * Upgrade a specified account.205 * 206 * - `origin`: Must be `Signed`.207 * - `who`: The account to be upgraded.208 * 209 * This will waive the transaction fee if at least all but 10% of the accounts needed to210 * be upgraded. (We let some not have to be upgraded just in order to allow for the211 * possibililty of churn).212 **/213 upgradeAccounts: AugmentedSubmittable<(who: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;214 /**215 * Generic tx216 **/217 [key: string]: SubmittableExtrinsicFunction<ApiType>;218 };219 collatorSelection: {220 /**221 * Add a collator to the list of invulnerable (fixed) collators.222 **/223 addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;224 /**225 * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.226 * Note that the collator can only leave on session change.227 * The `LicenseBond` will be unreserved and returned immediately.228 * 229 * This call is, of course, not applicable to `Invulnerable` collators.230 **/231 forceReleaseLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;232 /**233 * Purchase a license on block collation for this account.234 * It does not make it a collator candidate, use `onboard` afterward. The account must235 * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.236 * 237 * This call is not available to `Invulnerable` collators.238 **/239 getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;240 /**241 * Deregister `origin` as a collator candidate. Note that the collator can only leave on242 * session change. The license to `onboard` later at any other time will remain.243 **/244 offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;245 /**246 * Register this account as a candidate for collators for next sessions.247 * The account must already hold a license, and cannot offboard immediately during a session.248 * 249 * This call is not available to `Invulnerable` collators.250 **/251 onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;252 /**253 * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.254 * 255 * This call is not available to `Invulnerable` collators.256 **/257 releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;258 /**259 * Remove a collator from the list of invulnerable (fixed) collators.260 **/261 removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;262 /**263 * Generic tx264 **/265 [key: string]: SubmittableExtrinsicFunction<ApiType>;266 };267 configuration: {268 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;269 setCollatorSelectionDesiredCollators: AugmentedSubmittable<(max: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;270 setCollatorSelectionKickThreshold: AugmentedSubmittable<(threshold: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;271 setCollatorSelectionLicenseBond: AugmentedSubmittable<(amount: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u128>]>;272 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;273 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;274 /**275 * Generic tx276 **/277 [key: string]: SubmittableExtrinsicFunction<ApiType>;278 };279 cumulusXcm: {280 /**281 * Generic tx282 **/283 [key: string]: SubmittableExtrinsicFunction<ApiType>;284 };285 dmpQueue: {286 /**287 * Service a single overweight message.288 **/289 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;290 /**291 * Generic tx292 **/293 [key: string]: SubmittableExtrinsicFunction<ApiType>;294 };295 ethereum: {296 /**297 * Transact an Ethereum transaction.298 **/299 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;300 /**301 * Generic tx302 **/303 [key: string]: SubmittableExtrinsicFunction<ApiType>;304 };305 evm: {306 /**307 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.308 **/309 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>]>>]>;310 /**311 * Issue an EVM create operation. This is similar to a contract creation transaction in312 * Ethereum.313 **/314 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>]>>]>;315 /**316 * Issue an EVM create2 operation.317 **/318 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>]>>]>;319 /**320 * Withdraw balance from EVM into currency/balances pallet.321 **/322 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;323 /**324 * Generic tx325 **/326 [key: string]: SubmittableExtrinsicFunction<ApiType>;327 };328 evmCoderSubstrate: {329 emptyCall: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;330 /**331 * Generic tx332 **/333 [key: string]: SubmittableExtrinsicFunction<ApiType>;334 };335 evmContractHelpers: {336 /**337 * Migrate contract to use `SponsoringMode` storage instead of `SelfSponsoring`338 **/339 migrateFromSelfSponsoring: AugmentedSubmittable<(addresses: Vec<H160> | (H160 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<H160>]>;340 /**341 * Generic tx342 **/343 [key: string]: SubmittableExtrinsicFunction<ApiType>;344 };345 evmMigration: {346 /**347 * Start contract migration, inserts contract stub at target address,348 * and marks account as pending, allowing to insert storage349 **/350 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;351 /**352 * Finish contract migration, allows it to be called.353 * It is not possible to alter contract storage via [`Self::set_data`]354 * after this call.355 **/356 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;357 /**358 * Create ethereum events attached to the fake transaction359 **/360 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;361 /**362 * Create substrate events363 **/364 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;365 /**366 * Remove remark compatibility data leftovers367 **/368 removeRmrkData: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;369 /**370 * Insert items into contract storage, this method can be called371 * multiple times372 **/373 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;374 /**375 * Generic tx376 **/377 [key: string]: SubmittableExtrinsicFunction<ApiType>;378 };379 foreignAssets: {380 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]>;381 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]>;382 /**383 * Generic tx384 **/385 [key: string]: SubmittableExtrinsicFunction<ApiType>;386 };387 identity: {388 /**389 * Add a registrar to the system.390 * 391 * The dispatch origin for this call must be `T::RegistrarOrigin`.392 * 393 * - `account`: the account of the registrar.394 * 395 * Emits `RegistrarAdded` if successful.396 * 397 * # <weight>398 * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).399 * - One storage mutation (codec `O(R)`).400 * - One event.401 * # </weight>402 **/403 addRegistrar: AugmentedSubmittable<(account: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;404 /**405 * Add the given account to the sender's subs.406 * 407 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated408 * to the sender.409 * 410 * The dispatch origin for this call must be _Signed_ and the sender must have a registered411 * sub identity of `sub`.412 **/413 addSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Data]>;414 /**415 * Cancel a previous request.416 * 417 * Payment: A previously reserved deposit is returned on success.418 * 419 * The dispatch origin for this call must be _Signed_ and the sender must have a420 * registered identity.421 * 422 * - `reg_index`: The index of the registrar whose judgement is no longer requested.423 * 424 * Emits `JudgementUnrequested` if successful.425 * 426 * # <weight>427 * - `O(R + X)`.428 * - One balance-reserve operation.429 * - One storage mutation `O(R + X)`.430 * - One event431 * # </weight>432 **/433 cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;434 /**435 * Clear an account's identity info and all sub-accounts and return all deposits.436 * 437 * Payment: All reserved balances on the account are returned.438 * 439 * The dispatch origin for this call must be _Signed_ and the sender must have a registered440 * identity.441 * 442 * Emits `IdentityCleared` if successful.443 * 444 * # <weight>445 * - `O(R + S + X)`446 * - where `R` registrar-count (governance-bounded).447 * - where `S` subs-count (hard- and deposit-bounded).448 * - where `X` additional-field-count (deposit-bounded and code-bounded).449 * - One balance-unreserve operation.450 * - `2` storage reads and `S + 2` storage deletions.451 * - One event.452 * # </weight>453 **/454 clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;455 /**456 * Set identities to be associated with the provided accounts as force origin.457 * 458 * This is not meant to operate in tandem with the identity pallet as is,459 * and be instead used to keep identities made and verified externally,460 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.461 **/462 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]>>]>;463 /**464 * Remove identities associated with the provided accounts as force origin.465 * 466 * This is not meant to operate in tandem with the identity pallet as is,467 * and be instead used to keep identities made and verified externally,468 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.469 **/470 forceRemoveIdentities: AugmentedSubmittable<(identities: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;471 /**472 * Set sub-identities to be associated with the provided accounts as force origin.473 * 474 * This is not meant to operate in tandem with the identity pallet as is,475 * and be instead used to keep identities made and verified externally,476 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.477 **/478 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]>>]>]>>]>;479 /**480 * Remove an account's identity and sub-account information and slash the deposits.481 * 482 * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by483 * `Slash`. Verification request deposits are not returned; they should be cancelled484 * manually using `cancel_request`.485 * 486 * The dispatch origin for this call must match `T::ForceOrigin`.487 * 488 * - `target`: the account whose identity the judgement is upon. This must be an account489 * with a registered identity.490 * 491 * Emits `IdentityKilled` if successful.492 * 493 * # <weight>494 * - `O(R + S + X)`.495 * - One balance-reserve operation.496 * - `S + 2` storage mutations.497 * - One event.498 * # </weight>499 **/500 killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;501 /**502 * Provide a judgement for an account's identity.503 * 504 * The dispatch origin for this call must be _Signed_ and the sender must be the account505 * of the registrar whose index is `reg_index`.506 * 507 * - `reg_index`: the index of the registrar whose judgement is being made.508 * - `target`: the account whose identity the judgement is upon. This must be an account509 * with a registered identity.510 * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.511 * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.512 * 513 * Emits `JudgementGiven` if successful.514 * 515 * # <weight>516 * - `O(R + X)`.517 * - One balance-transfer operation.518 * - Up to one account-lookup operation.519 * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.520 * - One event.521 * # </weight>522 **/523 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]>;524 /**525 * Remove the sender as a sub-account.526 * 527 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated528 * to the sender (*not* the original depositor).529 * 530 * The dispatch origin for this call must be _Signed_ and the sender must have a registered531 * super-identity.532 * 533 * NOTE: This should not normally be used, but is provided in the case that the non-534 * controller of an account is maliciously registered as a sub-account.535 **/536 quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;537 /**538 * Remove the given account from the sender's subs.539 * 540 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated541 * to the sender.542 * 543 * The dispatch origin for this call must be _Signed_ and the sender must have a registered544 * sub identity of `sub`.545 **/546 removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;547 /**548 * Alter the associated name of the given sub-account.549 * 550 * The dispatch origin for this call must be _Signed_ and the sender must have a registered551 * sub identity of `sub`.552 **/553 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]>;554 /**555 * Request a judgement from a registrar.556 * 557 * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement558 * given.559 * 560 * The dispatch origin for this call must be _Signed_ and the sender must have a561 * registered identity.562 * 563 * - `reg_index`: The index of the registrar whose judgement is requested.564 * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:565 * 566 * ```nocompile567 * Self::registrars().get(reg_index).unwrap().fee568 * ```569 * 570 * Emits `JudgementRequested` if successful.571 * 572 * # <weight>573 * - `O(R + X)`.574 * - One balance-reserve operation.575 * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.576 * - One event.577 * # </weight>578 **/579 requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;580 /**581 * Change the account associated with a registrar.582 * 583 * The dispatch origin for this call must be _Signed_ and the sender must be the account584 * of the registrar whose index is `index`.585 * 586 * - `index`: the index of the registrar whose fee is to be set.587 * - `new`: the new account ID.588 * 589 * # <weight>590 * - `O(R)`.591 * - One storage mutation `O(R)`.592 * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)593 * # </weight>594 **/595 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]>;596 /**597 * Set the fee required for a judgement to be requested from a registrar.598 * 599 * The dispatch origin for this call must be _Signed_ and the sender must be the account600 * of the registrar whose index is `index`.601 * 602 * - `index`: the index of the registrar whose fee is to be set.603 * - `fee`: the new fee.604 * 605 * # <weight>606 * - `O(R)`.607 * - One storage mutation `O(R)`.608 * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)609 * # </weight>610 **/611 setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;612 /**613 * Set the field information for a registrar.614 * 615 * The dispatch origin for this call must be _Signed_ and the sender must be the account616 * of the registrar whose index is `index`.617 * 618 * - `index`: the index of the registrar whose fee is to be set.619 * - `fields`: the fields that the registrar concerns themselves with.620 * 621 * # <weight>622 * - `O(R)`.623 * - One storage mutation `O(R)`.624 * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)625 * # </weight>626 **/627 setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;628 /**629 * Set an account's identity information and reserve the appropriate deposit.630 * 631 * If the account already has identity information, the deposit is taken as part payment632 * for the new deposit.633 * 634 * The dispatch origin for this call must be _Signed_.635 * 636 * - `info`: The identity information.637 * 638 * Emits `IdentitySet` if successful.639 * 640 * # <weight>641 * - `O(X + X' + R)`642 * - where `X` additional-field-count (deposit-bounded and code-bounded)643 * - where `R` judgements-count (registrar-count-bounded)644 * - One balance reserve operation.645 * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).646 * - One event.647 * # </weight>648 **/649 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]>;650 /**651 * Set the sub-accounts of the sender.652 * 653 * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned654 * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.655 * 656 * The dispatch origin for this call must be _Signed_ and the sender must have a registered657 * identity.658 * 659 * - `subs`: The identity's (new) sub-accounts.660 * 661 * # <weight>662 * - `O(P + S)`663 * - where `P` old-subs-count (hard- and deposit-bounded).664 * - where `S` subs-count (hard- and deposit-bounded).665 * - At most one balance operations.666 * - DB:667 * - `P + S` storage mutations (codec complexity `O(1)`)668 * - One storage read (codec complexity `O(P)`).669 * - One storage write (codec complexity `O(S)`).670 * - One storage-exists (`IdentityOf::contains_key`).671 * # </weight>672 **/673 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]>>]>;674 /**675 * Generic tx676 **/677 [key: string]: SubmittableExtrinsicFunction<ApiType>;678 };679 inflation: {680 /**681 * This method sets the inflation start date. Can be only called once.682 * Inflation start block can be backdated and will catch up. The method will create Treasury683 * account if it does not exist and perform the first inflation deposit.684 * 685 * # Permissions686 * 687 * * Root688 * 689 * # Arguments690 * 691 * * inflation_start_relay_block: The relay chain block at which inflation should start692 **/693 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;694 /**695 * Generic tx696 **/697 [key: string]: SubmittableExtrinsicFunction<ApiType>;698 };699 maintenance: {700 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;701 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;702 /**703 * Execute a runtime call stored as a preimage.704 * 705 * `weight_bound` is the maximum weight that the caller is willing706 * to allow the extrinsic to be executed with.707 **/708 executePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array, weightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, SpWeightsWeightV2Weight]>;709 /**710 * Generic tx711 **/712 [key: string]: SubmittableExtrinsicFunction<ApiType>;713 };714 parachainInfo: {715 /**716 * Generic tx717 **/718 [key: string]: SubmittableExtrinsicFunction<ApiType>;719 };720 parachainSystem: {721 /**722 * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied723 * later.724 * 725 * The `check_version` parameter sets a boolean flag for whether or not the runtime's spec726 * version and name should be verified on upgrade. Since the authorization only has a hash,727 * it cannot actually perform the verification.728 * 729 * This call requires Root origin.730 **/731 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array, checkVersion: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, bool]>;732 /**733 * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.734 * 735 * If the authorization required a version check, this call will ensure the spec name736 * remains unchanged and that the spec version has increased.737 * 738 * Note that this function will not apply the new `code`, but only attempt to schedule the739 * upgrade with the Relay Chain.740 * 741 * All origins are allowed.742 **/743 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;744 /**745 * Set the current validation data.746 * 747 * This should be invoked exactly once per block. It will panic at the finalization748 * phase if the call was not invoked.749 * 750 * The dispatch origin for this call must be `Inherent`751 * 752 * As a side effect, this function upgrades the current validation function753 * if the appropriate time has come.754 **/755 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;756 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;757 /**758 * Generic tx759 **/760 [key: string]: SubmittableExtrinsicFunction<ApiType>;761 };762 polkadotXcm: {763 /**764 * Execute an XCM message from a local, signed, origin.765 * 766 * An event is deposited indicating whether `msg` could be executed completely or only767 * partially.768 * 769 * No more than `max_weight` will be used in its attempted execution. If this is less than the770 * maximum amount of weight that the message could take to be executed, then no execution771 * attempt will be made.772 * 773 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully774 * to completion; only that *some* of it was executed.775 **/776 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, SpWeightsWeightV2Weight]>;777 /**778 * Set a safe XCM version (the version that XCM should be encoded with if the most recent779 * version a destination can accept is unknown).780 * 781 * - `origin`: Must be an origin specified by AdminOrigin.782 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.783 **/784 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;785 /**786 * Ask a location to notify us regarding their XCM version and any changes to it.787 * 788 * - `origin`: Must be an origin specified by AdminOrigin.789 * - `location`: The location to which we should subscribe for XCM version notifications.790 **/791 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;792 /**793 * Set or unset the global suspension state of the XCM executor.794 * 795 * - `origin`: Must be an origin specified by AdminOrigin.796 * - `suspended`: `true` to suspend, `false` to resume.797 **/798 forceSuspension: AugmentedSubmittable<(suspended: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [bool]>;799 /**800 * Require that a particular destination should no longer notify us regarding any XCM801 * version changes.802 * 803 * - `origin`: Must be an origin specified by AdminOrigin.804 * - `location`: The location to which we are currently subscribed for XCM version805 * notifications which we no longer desire.806 **/807 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;808 /**809 * Extoll that a particular destination can be communicated with through a particular810 * version of XCM.811 * 812 * - `origin`: Must be an origin specified by AdminOrigin.813 * - `location`: The destination that is being described.814 * - `xcm_version`: The latest version of XCM that `location` supports.815 **/816 forceXcmVersion: AugmentedSubmittable<(location: XcmV3MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV3MultiLocation, u32]>;817 /**818 * Transfer some assets from the local chain to the sovereign account of a destination819 * chain and forward a notification XCM.820 * 821 * Fee payment on the destination side is made from the asset in the `assets` vector of822 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight823 * is needed than `weight_limit`, then the operation will fail and the assets send may be824 * at risk.825 * 826 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.827 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send828 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.829 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be830 * an `AccountId32` value.831 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the832 * `dest` side.833 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay834 * fees.835 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.836 **/837 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]>;838 /**839 * Teleport some assets from the local chain to some destination chain.840 * 841 * Fee payment on the destination side is made from the asset in the `assets` vector of842 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight843 * is needed than `weight_limit`, then the operation will fail and the assets send may be844 * at risk.845 * 846 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.847 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send848 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.849 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be850 * an `AccountId32` value.851 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the852 * `dest` side. May not be empty.853 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay854 * fees.855 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.856 **/857 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]>;858 /**859 * Transfer some assets from the local chain to the sovereign account of a destination860 * chain and forward a notification XCM.861 * 862 * Fee payment on the destination side is made from the asset in the `assets` vector of863 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,864 * with all fees taken as needed from the asset.865 * 866 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.867 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send868 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.869 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be870 * an `AccountId32` value.871 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the872 * `dest` side.873 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay874 * fees.875 **/876 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]>;877 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;878 /**879 * Teleport some assets from the local chain to some destination chain.880 * 881 * Fee payment on the destination side is made from the asset in the `assets` vector of882 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,883 * with all fees taken as needed from the asset.884 * 885 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.886 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send887 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.888 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be889 * an `AccountId32` value.890 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the891 * `dest` side. May not be empty.892 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay893 * fees.894 **/895 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]>;896 /**897 * Generic tx898 **/899 [key: string]: SubmittableExtrinsicFunction<ApiType>;900 };901 preimage: {902 /**903 * Register a preimage on-chain.904 * 905 * If the preimage was previously requested, no fees or deposits are taken for providing906 * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.907 **/908 notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;909 /**910 * Request a preimage be uploaded to the chain without paying any fees or deposits.911 * 912 * If the preimage requests has already been provided on-chain, we unreserve any deposit913 * a user may have paid, and take the control of the preimage out of their hands.914 **/915 requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;916 /**917 * Clear an unrequested preimage from the runtime storage.918 * 919 * If `len` is provided, then it will be a much cheaper operation.920 * 921 * - `hash`: The hash of the preimage to be removed from the store.922 * - `len`: The length of the preimage of `hash`.923 **/924 unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;925 /**926 * Clear a previously made request for a preimage.927 * 928 * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.929 **/930 unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;931 /**932 * Generic tx933 **/934 [key: string]: SubmittableExtrinsicFunction<ApiType>;935 };936 session: {937 /**938 * Removes any session key(s) of the function caller.939 * 940 * This doesn't take effect until the next session.941 * 942 * The dispatch origin of this function must be Signed and the account must be either be943 * convertible to a validator ID using the chain's typical addressing system (this usually944 * means being a controller account) or directly convertible into a validator ID (which945 * usually means being a stash account).946 * 947 * ## Complexity948 * - `O(1)` in number of key types. Actual cost depends on the number of length of949 * `T::Keys::key_ids()` which is fixed.950 **/951 purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;952 /**953 * Sets the session key(s) of the function caller to `keys`.954 * Allows an account to set its session key prior to becoming a validator.955 * This doesn't take effect until the next session.956 * 957 * The dispatch origin of this function must be signed.958 * 959 * ## Complexity960 * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is961 * fixed.962 **/963 setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;964 /**965 * Generic tx966 **/967 [key: string]: SubmittableExtrinsicFunction<ApiType>;968 };969 structure: {970 /**971 * Generic tx972 **/973 [key: string]: SubmittableExtrinsicFunction<ApiType>;974 };975 sudo: {976 /**977 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo978 * key.979 * 980 * The dispatch origin for this call must be _Signed_.981 * 982 * ## Complexity983 * - O(1).984 **/985 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;986 /**987 * Authenticates the sudo key and dispatches a function call with `Root` origin.988 * 989 * The dispatch origin for this call must be _Signed_.990 * 991 * ## Complexity992 * - O(1).993 **/994 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;995 /**996 * Authenticates the sudo key and dispatches a function call with `Signed` origin from997 * a given account.998 * 999 * The dispatch origin for this call must be _Signed_.1000 * 1001 * ## Complexity1002 * - O(1).1003 **/1004 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]>;1005 /**1006 * Authenticates the sudo key and dispatches a function call with `Root` origin.1007 * This function does not check the weight of the call, and instead allows the1008 * Sudo user to specify the weight of the call.1009 * 1010 * The dispatch origin for this call must be _Signed_.1011 * 1012 * ## Complexity1013 * - O(1).1014 **/1015 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;1016 /**1017 * Generic tx1018 **/1019 [key: string]: SubmittableExtrinsicFunction<ApiType>;1020 };1021 system: {1022 /**1023 * Kill all storage items with a key that starts with the given prefix.1024 * 1025 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1026 * the prefix we are removing to accurately calculate the weight of this function.1027 **/1028 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1029 /**1030 * Kill some items from storage.1031 **/1032 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1033 /**1034 * Make some on-chain remark.1035 * 1036 * ## Complexity1037 * - `O(1)`1038 **/1039 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1040 /**1041 * Make some on-chain remark and emit event.1042 **/1043 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1044 /**1045 * Set the new runtime code.1046 * 1047 * ## Complexity1048 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`1049 **/1050 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1051 /**1052 * Set the new runtime code without doing any checks of the given `code`.1053 * 1054 * ## Complexity1055 * - `O(C)` where `C` length of `code`1056 **/1057 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1058 /**1059 * Set the number of pages in the WebAssembly environment's heap.1060 **/1061 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1062 /**1063 * Set some items of storage.1064 **/1065 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1066 /**1067 * Generic tx1068 **/1069 [key: string]: SubmittableExtrinsicFunction<ApiType>;1070 };1071 testUtils: {1072 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1073 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1074 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1075 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1076 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1077 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1078 /**1079 * Generic tx1080 **/1081 [key: string]: SubmittableExtrinsicFunction<ApiType>;1082 };1083 timestamp: {1084 /**1085 * Set the current time.1086 * 1087 * This call should be invoked exactly once per block. It will panic at the finalization1088 * phase, if this call hasn't been invoked by that time.1089 * 1090 * The timestamp should be greater than the previous one by the amount specified by1091 * `MinimumPeriod`.1092 * 1093 * The dispatch origin for this call must be `Inherent`.1094 * 1095 * ## Complexity1096 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1097 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1098 * `on_finalize`)1099 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1100 **/1101 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1102 /**1103 * Generic tx1104 **/1105 [key: string]: SubmittableExtrinsicFunction<ApiType>;1106 };1107 tokens: {1108 /**1109 * Exactly as `transfer`, except the origin must be root and the source1110 * account may be specified.1111 * 1112 * The dispatch origin for this call must be _Root_.1113 * 1114 * - `source`: The sender of the transfer.1115 * - `dest`: The recipient of the transfer.1116 * - `currency_id`: currency type.1117 * - `amount`: free balance amount to tranfer.1118 **/1119 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>]>;1120 /**1121 * Set the balances of a given account.1122 * 1123 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1124 * will also decrease the total issuance of the system1125 * (`TotalIssuance`). If the new free or reserved balance is below the1126 * existential deposit, it will reap the `AccountInfo`.1127 * 1128 * The dispatch origin for this call is `root`.1129 **/1130 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>]>;1131 /**1132 * Transfer some liquid free balance to another account.1133 * 1134 * `transfer` will set the `FreeBalance` of the sender and receiver.1135 * It will decrease the total issuance of the system by the1136 * `TransferFee`. If the sender's account is below the existential1137 * deposit as a result of the transfer, the account will be reaped.1138 * 1139 * The dispatch origin for this call must be `Signed` by the1140 * transactor.1141 * 1142 * - `dest`: The recipient of the transfer.1143 * - `currency_id`: currency type.1144 * - `amount`: free balance amount to tranfer.1145 **/1146 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>]>;1147 /**1148 * Transfer all remaining balance to the given account.1149 * 1150 * NOTE: This function only attempts to transfer _transferable_1151 * balances. This means that any locked, reserved, or existential1152 * deposits (when `keep_alive` is `true`), will not be transferred by1153 * this function. To ensure that this function results in a killed1154 * account, you might need to prepare the account by removing any1155 * reference counters, storage deposits, etc...1156 * 1157 * The dispatch origin for this call must be `Signed` by the1158 * transactor.1159 * 1160 * - `dest`: The recipient of the transfer.1161 * - `currency_id`: currency type.1162 * - `keep_alive`: A boolean to determine if the `transfer_all`1163 * operation should send all of the funds the account has, causing1164 * the sender account to be killed (false), or transfer everything1165 * except at least the existential deposit, which will guarantee to1166 * keep the sender account alive (true).1167 **/1168 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]>;1169 /**1170 * Same as the [`transfer`] call, but with a check that the transfer1171 * will not kill the origin account.1172 * 1173 * 99% of the time you want [`transfer`] instead.1174 * 1175 * The dispatch origin for this call must be `Signed` by the1176 * transactor.1177 * 1178 * - `dest`: The recipient of the transfer.1179 * - `currency_id`: currency type.1180 * - `amount`: free balance amount to tranfer.1181 **/1182 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>]>;1183 /**1184 * Generic tx1185 **/1186 [key: string]: SubmittableExtrinsicFunction<ApiType>;1187 };1188 treasury: {1189 /**1190 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1191 * and the original deposit will be returned.1192 * 1193 * May only be called from `T::ApproveOrigin`.1194 * 1195 * ## Complexity1196 * - O(1).1197 **/1198 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1199 /**1200 * Put forward a suggestion for spending. A deposit proportional to the value1201 * is reserved and slashed if the proposal is rejected. It is returned once the1202 * proposal is awarded.1203 * 1204 * ## Complexity1205 * - O(1)1206 **/1207 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]>;1208 /**1209 * Reject a proposed spend. The original deposit will be slashed.1210 * 1211 * May only be called from `T::RejectOrigin`.1212 * 1213 * ## Complexity1214 * - O(1)1215 **/1216 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1217 /**1218 * Force a previously approved proposal to be removed from the approval queue.1219 * The original deposit will no longer be returned.1220 * 1221 * May only be called from `T::RejectOrigin`.1222 * - `proposal_id`: The index of a proposal1223 * 1224 * ## Complexity1225 * - O(A) where `A` is the number of approvals1226 * 1227 * Errors:1228 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1229 * i.e., the proposal has not been approved. This could also mean the proposal does not1230 * exist altogether, thus there is no way it would have been approved in the first place.1231 **/1232 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1233 /**1234 * Propose and approve a spend of treasury funds.1235 * 1236 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1237 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1238 * - `beneficiary`: The destination account for the transfer.1239 * 1240 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1241 * beneficiary.1242 **/1243 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]>;1244 /**1245 * Generic tx1246 **/1247 [key: string]: SubmittableExtrinsicFunction<ApiType>;1248 };1249 unique: {1250 /**1251 * Add an admin to a collection.1252 * 1253 * NFT Collection can be controlled by multiple admin addresses1254 * (some which can also be servers, for example). Admins can issue1255 * and burn NFTs, as well as add and remove other admins,1256 * but cannot change NFT or Collection ownership.1257 * 1258 * # Permissions1259 * 1260 * * Collection owner1261 * * Collection admin1262 * 1263 * # Arguments1264 * 1265 * * `collection_id`: ID of the Collection to add an admin for.1266 * * `new_admin`: Address of new admin to add.1267 **/1268 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1269 /**1270 * Add an address to allow list.1271 * 1272 * # Permissions1273 * 1274 * * Collection owner1275 * * Collection admin1276 * 1277 * # Arguments1278 * 1279 * * `collection_id`: ID of the modified collection.1280 * * `address`: ID of the address to be added to the allowlist.1281 **/1282 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1283 /**1284 * Allow a non-permissioned address to transfer or burn an item.1285 * 1286 * # Permissions1287 * 1288 * * Collection owner1289 * * Collection admin1290 * * Current item owner1291 * 1292 * # Arguments1293 * 1294 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1295 * * `collection_id`: ID of the collection the item belongs to.1296 * * `item_id`: ID of the item transactions on which are now approved.1297 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1298 * Set to 0 to revoke the approval.1299 **/1300 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]>;1301 /**1302 * Allow a non-permissioned address to transfer or burn an item from owner's eth mirror.1303 * 1304 * # Permissions1305 * 1306 * * Collection owner1307 * * Collection admin1308 * * Current item owner1309 * 1310 * # Arguments1311 * 1312 * * `from`: Owner's account eth mirror1313 * * `to`: Account to be approved to make specific transactions on non-owned tokens.1314 * * `collection_id`: ID of the collection the item belongs to.1315 * * `item_id`: ID of the item transactions on which are now approved.1316 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1317 * Set to 0 to revoke the approval.1318 **/1319 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]>;1320 /**1321 * Destroy a token on behalf of the owner as a non-owner account.1322 * 1323 * See also: [`approve`][`Pallet::approve`].1324 * 1325 * After this method executes, one approval is removed from the total so that1326 * the approved address will not be able to transfer this item again from this owner.1327 * 1328 * # Permissions1329 * 1330 * * Collection owner1331 * * Collection admin1332 * * Current token owner1333 * * Address approved by current item owner1334 * 1335 * # Arguments1336 * 1337 * * `from`: The owner of the burning item.1338 * * `collection_id`: ID of the collection to which the item belongs.1339 * * `item_id`: ID of item to burn.1340 * * `value`: Number of pieces to burn.1341 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1342 * * Fungible Mode: The desired number of pieces to burn.1343 * * Re-Fungible Mode: The desired number of pieces to burn.1344 **/1345 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]>;1346 /**1347 * Destroy an item.1348 * 1349 * # Permissions1350 * 1351 * * Collection owner1352 * * Collection admin1353 * * Current item owner1354 * 1355 * # Arguments1356 * 1357 * * `collection_id`: ID of the collection to which the item belongs.1358 * * `item_id`: ID of item to burn.1359 * * `value`: Number of pieces of the item to destroy.1360 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1361 * * Fungible Mode: The desired number of pieces to burn.1362 * * Re-Fungible Mode: The desired number of pieces to burn.1363 **/1364 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1365 /**1366 * Change the owner of the collection.1367 * 1368 * # Permissions1369 * 1370 * * Collection owner1371 * 1372 * # Arguments1373 * 1374 * * `collection_id`: ID of the modified collection.1375 * * `new_owner`: ID of the account that will become the owner.1376 **/1377 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1378 /**1379 * Confirm own sponsorship of a collection, becoming the sponsor.1380 * 1381 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1382 * Sponsor can pay the fees of a transaction instead of the sender,1383 * but only within specified limits.1384 * 1385 * # Permissions1386 * 1387 * * Sponsor-to-be1388 * 1389 * # Arguments1390 * 1391 * * `collection_id`: ID of the collection with the pending sponsor.1392 **/1393 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1394 /**1395 * Create a collection of tokens.1396 * 1397 * Each Token may have multiple properties encoded as an array of bytes1398 * of certain length. The initial owner of the collection is set1399 * to the address that signed the transaction and can be changed later.1400 * 1401 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1402 * 1403 * # Permissions1404 * 1405 * * Anyone - becomes the owner of the new collection.1406 * 1407 * # Arguments1408 * 1409 * * `collection_name`: Wide-character string with collection name1410 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1411 * * `collection_description`: Wide-character string with collection description1412 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1413 * * `token_prefix`: Byte string containing the token prefix to mark a collection1414 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1415 * * `mode`: Type of items stored in the collection and type dependent data.1416 * 1417 * returns collection ID1418 * 1419 * Deprecated: `create_collection_ex` is more up-to-date and advanced, prefer it instead.1420 **/1421 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]>;1422 /**1423 * Create a collection with explicit parameters.1424 * 1425 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1426 * 1427 * # Permissions1428 * 1429 * * Anyone - becomes the owner of the new collection.1430 * 1431 * # Arguments1432 * 1433 * * `data`: Explicit data of a collection used for its creation.1434 **/1435 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]>;1436 /**1437 * Mint an item within a collection.1438 * 1439 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1440 * 1441 * # Permissions1442 * 1443 * * Collection owner1444 * * Collection admin1445 * * Anyone if1446 * * Allow List is enabled, and1447 * * Address is added to allow list, and1448 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1449 * 1450 * # Arguments1451 * 1452 * * `collection_id`: ID of the collection to which an item would belong.1453 * * `owner`: Address of the initial owner of the item.1454 * * `data`: Token data describing the item to store on chain.1455 **/1456 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]>;1457 /**1458 * Create multiple items within a collection.1459 * 1460 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1461 * 1462 * # Permissions1463 * 1464 * * Collection owner1465 * * Collection admin1466 * * Anyone if1467 * * Allow List is enabled, and1468 * * Address is added to the allow list, and1469 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1470 * 1471 * # Arguments1472 * 1473 * * `collection_id`: ID of the collection to which the tokens would belong.1474 * * `owner`: Address of the initial owner of the tokens.1475 * * `items_data`: Vector of data describing each item to be created.1476 **/1477 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>]>;1478 /**1479 * Create multiple items within a collection with explicitly specified initial parameters.1480 * 1481 * # Permissions1482 * 1483 * * Collection owner1484 * * Collection admin1485 * * Anyone if1486 * * Allow List is enabled, and1487 * * Address is added to allow list, and1488 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1489 * 1490 * # Arguments1491 * 1492 * * `collection_id`: ID of the collection to which the tokens would belong.1493 * * `data`: Explicit item creation data.1494 **/1495 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1496 /**1497 * Delete specified collection properties.1498 * 1499 * # Permissions1500 * 1501 * * Collection Owner1502 * * Collection Admin1503 * 1504 * # Arguments1505 * 1506 * * `collection_id`: ID of the modified collection.1507 * * `property_keys`: Vector of keys of the properties to be deleted.1508 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1509 **/1510 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1511 /**1512 * Delete specified token properties. Currently properties only work with NFTs.1513 * 1514 * # Permissions1515 * 1516 * * Depends on collection's token property permissions and specified property mutability:1517 * * Collection owner1518 * * Collection admin1519 * * Token owner1520 * 1521 * # Arguments1522 * 1523 * * `collection_id`: ID of the collection to which the token belongs.1524 * * `token_id`: ID of the modified token.1525 * * `property_keys`: Vector of keys of the properties to be deleted.1526 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1527 **/1528 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1529 /**1530 * Destroy a collection if no tokens exist within.1531 * 1532 * # Permissions1533 * 1534 * * Collection owner1535 * 1536 * # Arguments1537 * 1538 * * `collection_id`: Collection to destroy.1539 **/1540 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1541 /**1542 * Repairs a collection if the data was somehow corrupted.1543 * 1544 * # Arguments1545 * 1546 * * `collection_id`: ID of the collection to repair.1547 **/1548 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1549 /**1550 * Repairs a token if the data was somehow corrupted.1551 * 1552 * # Arguments1553 * 1554 * * `collection_id`: ID of the collection the item belongs to.1555 * * `item_id`: ID of the item.1556 **/1557 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1558 /**1559 * Remove admin of a collection.1560 * 1561 * An admin address can remove itself. List of admins may become empty,1562 * in which case only Collection Owner will be able to add an Admin.1563 * 1564 * # Permissions1565 * 1566 * * Collection owner1567 * * Collection admin1568 * 1569 * # Arguments1570 * 1571 * * `collection_id`: ID of the collection to remove the admin for.1572 * * `account_id`: Address of the admin to remove.1573 **/1574 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1575 /**1576 * Remove a collection's a sponsor, making everyone pay for their own transactions.1577 * 1578 * # Permissions1579 * 1580 * * Collection owner1581 * 1582 * # Arguments1583 * 1584 * * `collection_id`: ID of the collection with the sponsor to remove.1585 **/1586 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1587 /**1588 * Remove an address from allow list.1589 * 1590 * # Permissions1591 * 1592 * * Collection owner1593 * * Collection admin1594 * 1595 * # Arguments1596 * 1597 * * `collection_id`: ID of the modified collection.1598 * * `address`: ID of the address to be removed from the allowlist.1599 **/1600 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1601 /**1602 * Re-partition a refungible token, while owning all of its parts/pieces.1603 * 1604 * # Permissions1605 * 1606 * * Token owner (must own every part)1607 * 1608 * # Arguments1609 * 1610 * * `collection_id`: ID of the collection the RFT belongs to.1611 * * `token_id`: ID of the RFT.1612 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1613 **/1614 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1615 /**1616 * Sets or unsets the approval of a given operator.1617 * 1618 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1619 * 1620 * # Arguments1621 * 1622 * * `owner`: Token owner1623 * * `operator`: Operator1624 * * `approve`: Should operator status be granted or revoked?1625 **/1626 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1627 /**1628 * Set specific limits of a collection. Empty, or None fields mean chain default.1629 * 1630 * # Permissions1631 * 1632 * * Collection owner1633 * * Collection admin1634 * 1635 * # Arguments1636 * 1637 * * `collection_id`: ID of the modified collection.1638 * * `new_limit`: New limits of the collection. Fields that are not set (None)1639 * will not overwrite the old ones.1640 **/1641 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]>;1642 /**1643 * Set specific permissions of a collection. Empty, or None fields mean chain default.1644 * 1645 * # Permissions1646 * 1647 * * Collection owner1648 * * Collection admin1649 * 1650 * # Arguments1651 * 1652 * * `collection_id`: ID of the modified collection.1653 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1654 * will not overwrite the old ones.1655 **/1656 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1657 /**1658 * Add or change collection properties.1659 * 1660 * # Permissions1661 * 1662 * * Collection owner1663 * * Collection admin1664 * 1665 * # Arguments1666 * 1667 * * `collection_id`: ID of the modified collection.1668 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1669 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1670 **/1671 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1672 /**1673 * Set (invite) a new collection sponsor.1674 * 1675 * If successful, confirmation from the sponsor-to-be will be pending.1676 * 1677 * # Permissions1678 * 1679 * * Collection owner1680 * * Collection admin1681 * 1682 * # Arguments1683 * 1684 * * `collection_id`: ID of the modified collection.1685 * * `new_sponsor`: ID of the account of the sponsor-to-be.1686 **/1687 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1688 /**1689 * Add or change token properties according to collection's permissions.1690 * Currently properties only work with NFTs.1691 * 1692 * # Permissions1693 * 1694 * * Depends on collection's token property permissions and specified property mutability:1695 * * Collection owner1696 * * Collection admin1697 * * Token owner1698 * 1699 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1700 * 1701 * # Arguments1702 * 1703 * * `collection_id: ID of the collection to which the token belongs.1704 * * `token_id`: ID of the modified token.1705 * * `properties`: Vector of key-value pairs stored as the token's metadata.1706 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1707 **/1708 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>]>;1709 /**1710 * Add or change token property permissions of a collection.1711 * 1712 * Without a permission for a particular key, a property with that key1713 * cannot be created in a token.1714 * 1715 * # Permissions1716 * 1717 * * Collection owner1718 * * Collection admin1719 * 1720 * # Arguments1721 * 1722 * * `collection_id`: ID of the modified collection.1723 * * `property_permissions`: Vector of permissions for property keys.1724 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1725 **/1726 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1727 /**1728 * Completely allow or disallow transfers for a particular collection.1729 * 1730 * # Permissions1731 * 1732 * * Collection owner1733 * 1734 * # Arguments1735 * 1736 * * `collection_id`: ID of the collection.1737 * * `value`: New value of the flag, are transfers allowed?1738 **/1739 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1740 /**1741 * Change ownership of the token.1742 * 1743 * # Permissions1744 * 1745 * * Collection owner1746 * * Collection admin1747 * * Current token owner1748 * 1749 * # Arguments1750 * 1751 * * `recipient`: Address of token recipient.1752 * * `collection_id`: ID of the collection the item belongs to.1753 * * `item_id`: ID of the item.1754 * * Non-Fungible Mode: Required.1755 * * Fungible Mode: Ignored.1756 * * Re-Fungible Mode: Required.1757 * 1758 * * `value`: Amount to transfer.1759 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1760 * * Fungible Mode: The desired number of pieces to transfer.1761 * * Re-Fungible Mode: The desired number of pieces to transfer.1762 **/1763 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]>;1764 /**1765 * Change ownership of an item on behalf of the owner as a non-owner account.1766 * 1767 * See the [`approve`][`Pallet::approve`] method for additional information.1768 * 1769 * After this method executes, one approval is removed from the total so that1770 * the approved address will not be able to transfer this item again from this owner.1771 * 1772 * # Permissions1773 * 1774 * * Collection owner1775 * * Collection admin1776 * * Current item owner1777 * * Address approved by current item owner1778 * 1779 * # Arguments1780 * 1781 * * `from`: Address that currently owns the token.1782 * * `recipient`: Address of the new token-owner-to-be.1783 * * `collection_id`: ID of the collection the item.1784 * * `item_id`: ID of the item to be transferred.1785 * * `value`: Amount to transfer.1786 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1787 * * Fungible Mode: The desired number of pieces to transfer.1788 * * Re-Fungible Mode: The desired number of pieces to transfer.1789 **/1790 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]>;1791 /**1792 * Generic tx1793 **/1794 [key: string]: SubmittableExtrinsicFunction<ApiType>;1795 };1796 vesting: {1797 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1798 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1799 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>]>;1800 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]>;1801 /**1802 * Generic tx1803 **/1804 [key: string]: SubmittableExtrinsicFunction<ApiType>;1805 };1806 xcmpQueue: {1807 /**1808 * Resumes all XCM executions for the XCMP queue.1809 * 1810 * Note that this function doesn't change the status of the in/out bound channels.1811 * 1812 * - `origin`: Must pass `ControllerOrigin`.1813 **/1814 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1815 /**1816 * Services a single overweight XCM.1817 * 1818 * - `origin`: Must pass `ExecuteOverweightOrigin`.1819 * - `index`: The index of the overweight XCM to service1820 * - `weight_limit`: The amount of weight that XCM execution may take.1821 * 1822 * Errors:1823 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1824 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1825 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1826 * 1827 * Events:1828 * - `OverweightServiced`: On success.1829 **/1830 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;1831 /**1832 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1833 * 1834 * - `origin`: Must pass `ControllerOrigin`.1835 **/1836 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1837 /**1838 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1839 * messages from the channel.1840 * 1841 * - `origin`: Must pass `Root`.1842 * - `new`: Desired value for `QueueConfigData.drop_threshold`1843 **/1844 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1845 /**1846 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1847 * message sending may recommence after it has been suspended.1848 * 1849 * - `origin`: Must pass `Root`.1850 * - `new`: Desired value for `QueueConfigData.resume_threshold`1851 **/1852 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1853 /**1854 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1855 * suspend their sending.1856 * 1857 * - `origin`: Must pass `Root`.1858 * - `new`: Desired value for `QueueConfigData.suspend_value`1859 **/1860 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1861 /**1862 * Overwrites the amount of remaining weight under which we stop processing messages.1863 * 1864 * - `origin`: Must pass `Root`.1865 * - `new`: Desired value for `QueueConfigData.threshold_weight`1866 **/1867 updateThresholdWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1868 /**1869 * Overwrites the speed to which the available weight approaches the maximum weight.1870 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1871 * 1872 * - `origin`: Must pass `Root`.1873 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1874 **/1875 updateWeightRestrictDecay: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1876 /**1877 * Overwrite the maximum amount of weight any individual message may consume.1878 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1879 * 1880 * - `origin`: Must pass `Root`.1881 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1882 **/1883 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1884 /**1885 * Generic tx1886 **/1887 [key: string]: SubmittableExtrinsicFunction<ApiType>;1888 };1889 xTokens: {1890 /**1891 * Transfer native currencies.1892 * 1893 * `dest_weight_limit` is the weight for XCM execution on the dest1894 * chain, and it would be charged from the transferred assets. If set1895 * below requirements, the execution may fail and assets wouldn't be1896 * received.1897 * 1898 * It's a no-op if any error on local XCM execution or message sending.1899 * Note sending assets out per se doesn't guarantee they would be1900 * received. Receiving depends on if the XCM message could be delivered1901 * by the network, and if the receiving chain would handle1902 * messages correctly.1903 **/1904 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]>;1905 /**1906 * Transfer `MultiAsset`.1907 * 1908 * `dest_weight_limit` is the weight for XCM execution on the dest1909 * chain, and it would be charged from the transferred assets. If set1910 * below requirements, the execution may fail and assets wouldn't be1911 * received.1912 * 1913 * It's a no-op if any error on local XCM execution or message sending.1914 * Note sending assets out per se doesn't guarantee they would be1915 * received. Receiving depends on if the XCM message could be delivered1916 * by the network, and if the receiving chain would handle1917 * messages correctly.1918 **/1919 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]>;1920 /**1921 * Transfer several `MultiAsset` specifying the item to be used as fee1922 * 1923 * `dest_weight_limit` is the weight for XCM execution on the dest1924 * chain, and it would be charged from the transferred assets. If set1925 * below requirements, the execution may fail and assets wouldn't be1926 * received.1927 * 1928 * `fee_item` is index of the MultiAssets that we want to use for1929 * payment1930 * 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 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]>;1938 /**1939 * Transfer `MultiAsset` specifying the fee and amount as separate.1940 * 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` is the multiasset to be spent to pay for execution in1947 * destination chain. Both fee and amount will be subtracted form the1948 * callers balance For now we only accept fee and asset having the same1949 * `MultiLocation` id.1950 * 1951 * If `fee` is not high enough to cover for the execution costs in the1952 * destination chain, then the assets will be trapped in the1953 * destination chain1954 * 1955 * It's a no-op if any error on local XCM execution or message sending.1956 * Note sending assets out per se doesn't guarantee they would be1957 * received. Receiving depends on if the XCM message could be delivered1958 * by the network, and if the receiving chain would handle1959 * messages correctly.1960 **/1961 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]>;1962 /**1963 * Transfer several currencies specifying the item to be used as fee1964 * 1965 * `dest_weight_limit` is the weight for XCM execution on the dest1966 * chain, and it would be charged from the transferred assets. If set1967 * below requirements, the execution may fail and assets wouldn't be1968 * received.1969 * 1970 * `fee_item` is index of the currencies tuple that we want to use for1971 * payment1972 * 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 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]>;1980 /**1981 * Transfer native currencies specifying the fee and amount as1982 * separate.1983 * 1984 * `dest_weight_limit` is the weight for XCM execution on the dest1985 * chain, and it would be charged from the transferred assets. If set1986 * below requirements, the execution may fail and assets wouldn't be1987 * received.1988 * 1989 * `fee` is the amount to be spent to pay for execution in destination1990 * chain. Both fee and amount will be subtracted form the callers1991 * balance.1992 * 1993 * If `fee` is not high enough to cover for the execution costs in the1994 * destination chain, then the assets will be trapped in the1995 * destination chain1996 * 1997 * It's a no-op if any error on local XCM execution or message sending.1998 * Note sending assets out per se doesn't guarantee they would be1999 * received. Receiving depends on if the XCM message could be delivered2000 * by the network, and if the receiving chain would handle2001 * messages correctly.2002 **/2003 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]>;2004 /**2005 * Generic tx2006 **/2007 [key: string]: SubmittableExtrinsicFunction<ApiType>;2008 };2009 } // AugmentedSubmittables2010} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts108.6 KiBsourcehistory