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, SpRuntimeHeader, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1415export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;16export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;17export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1819declare module '@polkadot/api-base/types/submittable' {20 interface AugmentedSubmittables<ApiType extends ApiTypes> {21 appPromotion: {22 /**23 * Recalculates interest for the specified number of stakers.24 * If all stakers are not recalculated, the next call of the extrinsic25 * will continue the recalculation, from those stakers for whom this26 * was not perform in last call.27 * 28 * # Permissions29 * 30 * * Pallet admin31 * 32 * # Arguments33 * 34 * * `stakers_number`: the number of stakers for which recalculation will be performed35 **/36 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;37 /**38 * Sets an address as the the admin.39 * 40 * # Permissions41 * 42 * * Sudo43 * 44 * # Arguments45 * 46 * * `admin`: account of the new admin.47 **/48 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;49 /**50 * Sets the pallet to be the sponsor for the collection.51 * 52 * # Permissions53 * 54 * * Pallet admin55 * 56 * # Arguments57 * 58 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`59 **/60 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;61 /**62 * Sets the pallet to be the sponsor for the contract.63 * 64 * # Permissions65 * 66 * * Pallet admin67 * 68 * # Arguments69 * 70 * * `contract_id`: the contract address that will be sponsored by `pallet_id`71 **/72 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;73 /**74 * Stakes the amount of native tokens.75 * Sets `amount` to the locked state.76 * The maximum number of stakes for a staker is 10.77 * 78 * # Arguments79 * 80 * * `amount`: in native tokens.81 **/82 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;83 /**84 * Removes the pallet as the sponsor for the collection.85 * Returns [`NoPermission`][`Error::NoPermission`]86 * if the pallet wasn't the sponsor.87 * 88 * # Permissions89 * 90 * * Pallet admin91 * 92 * # Arguments93 * 94 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`95 **/96 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;97 /**98 * Removes the pallet as the sponsor for the contract.99 * Returns [`NoPermission`][`Error::NoPermission`]100 * if the pallet wasn't the sponsor.101 * 102 * # Permissions103 * 104 * * Pallet admin105 * 106 * # Arguments107 * 108 * * `contract_id`: the contract address that is sponsored by `pallet_id`109 **/110 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;111 /**112 * Unstakes all stakes.113 * 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 authorship: {134 /**135 * Provide a set of uncles.136 **/137 setUncles: AugmentedSubmittable<(newUncles: Vec<SpRuntimeHeader> | (SpRuntimeHeader | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<SpRuntimeHeader>]>;138 /**139 * Generic tx140 **/141 [key: string]: SubmittableExtrinsicFunction<ApiType>;142 };143 balances: {144 /**145 * Exactly as `transfer`, except the origin must be root and the source account may be146 * specified.147 * # <weight>148 * - Same as transfer, but additional read and write because the source account is not149 * assumed to be in the overlay.150 * # </weight>151 **/152 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>]>;153 /**154 * Unreserve some balance from a user by force.155 * 156 * Can only be called by ROOT.157 **/158 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;159 /**160 * Set the balances of a given account.161 * 162 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will163 * also alter the total issuance of the system (`TotalIssuance`) appropriately.164 * If the new free or reserved balance is below the existential deposit,165 * it will reset the account nonce (`frame_system::AccountNonce`).166 * 167 * The dispatch origin for this call is `root`.168 **/169 setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;170 /**171 * Transfer some liquid free balance to another account.172 * 173 * `transfer` will set the `FreeBalance` of the sender and receiver.174 * If the sender's account is below the existential deposit as a result175 * of the transfer, the account will be reaped.176 * 177 * The dispatch origin for this call must be `Signed` by the transactor.178 * 179 * # <weight>180 * - Dependent on arguments but not critical, given proper implementations for input config181 * types. See related functions below.182 * - It contains a limited number of reads and writes internally and no complex183 * computation.184 * 185 * Related functions:186 * 187 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.188 * - Transferring balances to accounts that did not exist before will cause189 * `T::OnNewAccount::on_new_account` to be called.190 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.191 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check192 * that the transfer will not kill the origin account.193 * ---------------------------------194 * - Origin account is already in memory, so no DB operations for them.195 * # </weight>196 **/197 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>]>;198 /**199 * Transfer the entire transferable balance from the caller account.200 * 201 * NOTE: This function only attempts to transfer _transferable_ balances. This means that202 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be203 * transferred by this function. To ensure that this function results in a killed account,204 * you might need to prepare the account by removing any reference counters, storage205 * deposits, etc...206 * 207 * The dispatch origin of this call must be Signed.208 * 209 * - `dest`: The recipient of the transfer.210 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all211 * of the funds the account has, causing the sender account to be killed (false), or212 * transfer everything except at least the existential deposit, which will guarantee to213 * keep the sender account alive (true). # <weight>214 * - O(1). Just like transfer, but reading the user's transferable balance first.215 * #</weight>216 **/217 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;218 /**219 * Same as the [`transfer`] call, but with a check that the transfer will not kill the220 * origin account.221 * 222 * 99% of the time you want [`transfer`] instead.223 * 224 * [`transfer`]: struct.Pallet.html#method.transfer225 **/226 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>]>;227 /**228 * Generic tx229 **/230 [key: string]: SubmittableExtrinsicFunction<ApiType>;231 };232 charging: {233 /**234 * Generic tx235 **/236 [key: string]: SubmittableExtrinsicFunction<ApiType>;237 };238 collatorSelection: {239 /**240 * Add a collator to the list of invulnerable (fixed) collators.241 **/242 addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;243 /**244 * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.245 * Note that the collator can only leave on session change.246 * The `LicenseBond` will be unreserved and returned immediately.247 * 248 * This call is, of course, not applicable to `Invulnerable` collators.249 **/250 forceReleaseLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;251 /**252 * Purchase a license on block collation for this account.253 * It does not make it a collator candidate, use `onboard` afterward. The account must254 * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.255 * 256 * This call is not available to `Invulnerable` collators.257 **/258 getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;259 /**260 * Deregister `origin` as a collator candidate. Note that the collator can only leave on261 * session change. The license to `onboard` later at any other time will remain.262 **/263 offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;264 /**265 * Register this account as a candidate for collators for next sessions.266 * The account must already hold a license, and cannot offboard immediately during a session.267 * 268 * This call is not available to `Invulnerable` collators.269 **/270 onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;271 /**272 * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.273 * 274 * This call is not available to `Invulnerable` collators.275 **/276 releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;277 /**278 * Remove a collator from the list of invulnerable (fixed) collators.279 **/280 removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;281 /**282 * Generic tx283 **/284 [key: string]: SubmittableExtrinsicFunction<ApiType>;285 };286 configuration: {287 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;288 setCollatorSelectionDesiredCollators: AugmentedSubmittable<(max: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;289 setCollatorSelectionKickThreshold: AugmentedSubmittable<(threshold: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;290 setCollatorSelectionLicenseBond: AugmentedSubmittable<(amount: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u128>]>;291 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;292 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;293 setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;294 /**295 * Generic tx296 **/297 [key: string]: SubmittableExtrinsicFunction<ApiType>;298 };299 cumulusXcm: {300 /**301 * Generic tx302 **/303 [key: string]: SubmittableExtrinsicFunction<ApiType>;304 };305 dmpQueue: {306 /**307 * Service a single overweight message.308 * 309 * - `origin`: Must pass `ExecuteOverweightOrigin`.310 * - `index`: The index of the overweight message to service.311 * - `weight_limit`: The amount of weight that message execution may take.312 * 313 * Errors:314 * - `Unknown`: Message of `index` is unknown.315 * - `OverLimit`: Message execution may use greater than `weight_limit`.316 * 317 * Events:318 * - `OverweightServiced`: On success.319 **/320 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;321 /**322 * Generic tx323 **/324 [key: string]: SubmittableExtrinsicFunction<ApiType>;325 };326 ethereum: {327 /**328 * Transact an Ethereum transaction.329 **/330 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;331 /**332 * Generic tx333 **/334 [key: string]: SubmittableExtrinsicFunction<ApiType>;335 };336 evm: {337 /**338 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.339 **/340 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>]>>]>;341 /**342 * Issue an EVM create operation. This is similar to a contract creation transaction in343 * Ethereum.344 **/345 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>]>>]>;346 /**347 * Issue an EVM create2 operation.348 **/349 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>]>>]>;350 /**351 * Withdraw balance from EVM into currency/balances pallet.352 **/353 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;354 /**355 * Generic tx356 **/357 [key: string]: SubmittableExtrinsicFunction<ApiType>;358 };359 evmMigration: {360 /**361 * Start contract migration, inserts contract stub at target address,362 * and marks account as pending, allowing to insert storage363 **/364 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;365 /**366 * Finish contract migration, allows it to be called.367 * It is not possible to alter contract storage via [`Self::set_data`]368 * after this call.369 **/370 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;371 /**372 * Create ethereum events attached to the fake transaction373 **/374 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;375 /**376 * Create substrate events377 **/378 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;379 /**380 * Remove remark compatibility data leftovers381 **/382 removeRmrkData: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;383 /**384 * Insert items into contract storage, this method can be called385 * multiple times386 **/387 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;388 /**389 * Generic tx390 **/391 [key: string]: SubmittableExtrinsicFunction<ApiType>;392 };393 foreignAssets: {394 registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;395 updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;396 /**397 * Generic tx398 **/399 [key: string]: SubmittableExtrinsicFunction<ApiType>;400 };401 identity: {402 /**403 * Add a registrar to the system.404 * 405 * The dispatch origin for this call must be `T::RegistrarOrigin`.406 * 407 * - `account`: the account of the registrar.408 * 409 * Emits `RegistrarAdded` if successful.410 * 411 * # <weight>412 * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).413 * - One storage mutation (codec `O(R)`).414 * - One event.415 * # </weight>416 **/417 addRegistrar: AugmentedSubmittable<(account: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;418 /**419 * Add the given account to the sender's subs.420 * 421 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated422 * to the sender.423 * 424 * The dispatch origin for this call must be _Signed_ and the sender must have a registered425 * sub identity of `sub`.426 **/427 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]>;428 /**429 * Cancel a previous request.430 * 431 * Payment: A previously reserved deposit is returned on success.432 * 433 * The dispatch origin for this call must be _Signed_ and the sender must have a434 * registered identity.435 * 436 * - `reg_index`: The index of the registrar whose judgement is no longer requested.437 * 438 * Emits `JudgementUnrequested` if successful.439 * 440 * # <weight>441 * - `O(R + X)`.442 * - One balance-reserve operation.443 * - One storage mutation `O(R + X)`.444 * - One event445 * # </weight>446 **/447 cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;448 /**449 * Clear an account's identity info and all sub-accounts and return all deposits.450 * 451 * Payment: All reserved balances on the account are returned.452 * 453 * The dispatch origin for this call must be _Signed_ and the sender must have a registered454 * identity.455 * 456 * Emits `IdentityCleared` if successful.457 * 458 * # <weight>459 * - `O(R + S + X)`460 * - where `R` registrar-count (governance-bounded).461 * - where `S` subs-count (hard- and deposit-bounded).462 * - where `X` additional-field-count (deposit-bounded and code-bounded).463 * - One balance-unreserve operation.464 * - `2` storage reads and `S + 2` storage deletions.465 * - One event.466 * # </weight>467 **/468 clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;469 /**470 * Set identities to be associated with the provided accounts as force origin.471 * 472 * This is not meant to operate in tandem with the identity pallet as is,473 * and be instead used to keep identities made and verified externally,474 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.475 **/476 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]>>]>;477 /**478 * Remove identities associated with the provided accounts as force origin.479 * 480 * This is not meant to operate in tandem with the identity pallet as is,481 * and be instead used to keep identities made and verified externally,482 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.483 **/484 forceRemoveIdentities: AugmentedSubmittable<(identities: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;485 /**486 * Set sub-identities to be associated with the provided accounts as force origin.487 * 488 * This is not meant to operate in tandem with the identity pallet as is,489 * and be instead used to keep identities made and verified externally,490 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.491 **/492 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]>>]>]>>]>;493 /**494 * Remove an account's identity and sub-account information and slash the deposits.495 * 496 * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by497 * `Slash`. Verification request deposits are not returned; they should be cancelled498 * manually using `cancel_request`.499 * 500 * The dispatch origin for this call must match `T::ForceOrigin`.501 * 502 * - `target`: the account whose identity the judgement is upon. This must be an account503 * with a registered identity.504 * 505 * Emits `IdentityKilled` if successful.506 * 507 * # <weight>508 * - `O(R + S + X)`.509 * - One balance-reserve operation.510 * - `S + 2` storage mutations.511 * - One event.512 * # </weight>513 **/514 killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;515 /**516 * Provide a judgement for an account's identity.517 * 518 * The dispatch origin for this call must be _Signed_ and the sender must be the account519 * of the registrar whose index is `reg_index`.520 * 521 * - `reg_index`: the index of the registrar whose judgement is being made.522 * - `target`: the account whose identity the judgement is upon. This must be an account523 * with a registered identity.524 * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.525 * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.526 * 527 * Emits `JudgementGiven` if successful.528 * 529 * # <weight>530 * - `O(R + X)`.531 * - One balance-transfer operation.532 * - Up to one account-lookup operation.533 * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.534 * - One event.535 * # </weight>536 **/537 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]>;538 /**539 * Remove the sender as a sub-account.540 * 541 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated542 * to the sender (*not* the original depositor).543 * 544 * The dispatch origin for this call must be _Signed_ and the sender must have a registered545 * super-identity.546 * 547 * NOTE: This should not normally be used, but is provided in the case that the non-548 * controller of an account is maliciously registered as a sub-account.549 **/550 quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;551 /**552 * Remove the given account from the sender's subs.553 * 554 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated555 * to the sender.556 * 557 * The dispatch origin for this call must be _Signed_ and the sender must have a registered558 * sub identity of `sub`.559 **/560 removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;561 /**562 * Alter the associated name of the given sub-account.563 * 564 * The dispatch origin for this call must be _Signed_ and the sender must have a registered565 * sub identity of `sub`.566 **/567 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]>;568 /**569 * Request a judgement from a registrar.570 * 571 * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement572 * given.573 * 574 * The dispatch origin for this call must be _Signed_ and the sender must have a575 * registered identity.576 * 577 * - `reg_index`: The index of the registrar whose judgement is requested.578 * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:579 * 580 * ```nocompile581 * Self::registrars().get(reg_index).unwrap().fee582 * ```583 * 584 * Emits `JudgementRequested` if successful.585 * 586 * # <weight>587 * - `O(R + X)`.588 * - One balance-reserve operation.589 * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.590 * - One event.591 * # </weight>592 **/593 requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;594 /**595 * Change the account associated with a registrar.596 * 597 * The dispatch origin for this call must be _Signed_ and the sender must be the account598 * of the registrar whose index is `index`.599 * 600 * - `index`: the index of the registrar whose fee is to be set.601 * - `new`: the new account ID.602 * 603 * # <weight>604 * - `O(R)`.605 * - One storage mutation `O(R)`.606 * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)607 * # </weight>608 **/609 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]>;610 /**611 * Set the fee required for a judgement to be requested from a registrar.612 * 613 * The dispatch origin for this call must be _Signed_ and the sender must be the account614 * of the registrar whose index is `index`.615 * 616 * - `index`: the index of the registrar whose fee is to be set.617 * - `fee`: the new fee.618 * 619 * # <weight>620 * - `O(R)`.621 * - One storage mutation `O(R)`.622 * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)623 * # </weight>624 **/625 setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;626 /**627 * Set the field information for a registrar.628 * 629 * The dispatch origin for this call must be _Signed_ and the sender must be the account630 * of the registrar whose index is `index`.631 * 632 * - `index`: the index of the registrar whose fee is to be set.633 * - `fields`: the fields that the registrar concerns themselves with.634 * 635 * # <weight>636 * - `O(R)`.637 * - One storage mutation `O(R)`.638 * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)639 * # </weight>640 **/641 setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;642 /**643 * Set an account's identity information and reserve the appropriate deposit.644 * 645 * If the account already has identity information, the deposit is taken as part payment646 * for the new deposit.647 * 648 * The dispatch origin for this call must be _Signed_.649 * 650 * - `info`: The identity information.651 * 652 * Emits `IdentitySet` if successful.653 * 654 * # <weight>655 * - `O(X + X' + R)`656 * - where `X` additional-field-count (deposit-bounded and code-bounded)657 * - where `R` judgements-count (registrar-count-bounded)658 * - One balance reserve operation.659 * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).660 * - One event.661 * # </weight>662 **/663 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]>;664 /**665 * Set the sub-accounts of the sender.666 * 667 * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned668 * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.669 * 670 * The dispatch origin for this call must be _Signed_ and the sender must have a registered671 * identity.672 * 673 * - `subs`: The identity's (new) sub-accounts.674 * 675 * # <weight>676 * - `O(P + S)`677 * - where `P` old-subs-count (hard- and deposit-bounded).678 * - where `S` subs-count (hard- and deposit-bounded).679 * - At most one balance operations.680 * - DB:681 * - `P + S` storage mutations (codec complexity `O(1)`)682 * - One storage read (codec complexity `O(P)`).683 * - One storage write (codec complexity `O(S)`).684 * - One storage-exists (`IdentityOf::contains_key`).685 * # </weight>686 **/687 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]>>]>;688 /**689 * Generic tx690 **/691 [key: string]: SubmittableExtrinsicFunction<ApiType>;692 };693 inflation: {694 /**695 * This method sets the inflation start date. Can be only called once.696 * Inflation start block can be backdated and will catch up. The method will create Treasury697 * account if it does not exist and perform the first inflation deposit.698 * 699 * # Permissions700 * 701 * * Root702 * 703 * # Arguments704 * 705 * * inflation_start_relay_block: The relay chain block at which inflation should start706 **/707 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;708 /**709 * Generic tx710 **/711 [key: string]: SubmittableExtrinsicFunction<ApiType>;712 };713 maintenance: {714 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;715 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;716 /**717 * Execute a runtime call stored as a preimage.718 * 719 * `weight_bound` is the maximum weight that the caller is willing720 * to allow the extrinsic to be executed with.721 **/722 executePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array, weightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, SpWeightsWeightV2Weight]>;723 /**724 * Generic tx725 **/726 [key: string]: SubmittableExtrinsicFunction<ApiType>;727 };728 parachainSystem: {729 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;730 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;731 /**732 * Set the current validation data.733 * 734 * This should be invoked exactly once per block. It will panic at the finalization735 * phase if the call was not invoked.736 * 737 * The dispatch origin for this call must be `Inherent`738 * 739 * As a side effect, this function upgrades the current validation function740 * if the appropriate time has come.741 **/742 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;743 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;744 /**745 * Generic tx746 **/747 [key: string]: SubmittableExtrinsicFunction<ApiType>;748 };749 polkadotXcm: {750 /**751 * Execute an XCM message from a local, signed, origin.752 * 753 * An event is deposited indicating whether `msg` could be executed completely or only754 * partially.755 * 756 * No more than `max_weight` will be used in its attempted execution. If this is less than the757 * maximum amount of weight that the message could take to be executed, then no execution758 * attempt will be made.759 * 760 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully761 * to completion; only that *some* of it was executed.762 **/763 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;764 /**765 * Set a safe XCM version (the version that XCM should be encoded with if the most recent766 * version a destination can accept is unknown).767 * 768 * - `origin`: Must be Root.769 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.770 **/771 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;772 /**773 * Ask a location to notify us regarding their XCM version and any changes to it.774 * 775 * - `origin`: Must be Root.776 * - `location`: The location to which we should subscribe for XCM version notifications.777 **/778 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;779 /**780 * Require that a particular destination should no longer notify us regarding any XCM781 * version changes.782 * 783 * - `origin`: Must be Root.784 * - `location`: The location to which we are currently subscribed for XCM version785 * notifications which we no longer desire.786 **/787 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;788 /**789 * Extoll that a particular destination can be communicated with through a particular790 * version of XCM.791 * 792 * - `origin`: Must be Root.793 * - `location`: The destination that is being described.794 * - `xcm_version`: The latest version of XCM that `location` supports.795 **/796 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;797 /**798 * Transfer some assets from the local chain to the sovereign account of a destination799 * chain and forward a notification XCM.800 * 801 * Fee payment on the destination side is made from the asset in the `assets` vector of802 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight803 * is needed than `weight_limit`, then the operation will fail and the assets send may be804 * at risk.805 * 806 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.807 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send808 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.809 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be810 * an `AccountId32` value.811 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the812 * `dest` side.813 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay814 * fees.815 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.816 **/817 limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>;818 /**819 * Teleport some assets from the local chain to some destination chain.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. The first item should be the currency used to to pay the fee on the832 * `dest` side. May not be empty.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 limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>;838 /**839 * Transfer some assets from the local chain to the sovereign account of a destination840 * chain and forward a notification XCM.841 * 842 * Fee payment on the destination side is made from the asset in the `assets` vector of843 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,844 * with all fees taken as needed from the asset.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. This should include the assets used to pay the fee on the852 * `dest` side.853 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay854 * fees.855 **/856 reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;857 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;858 /**859 * Teleport some assets from the local chain to some destination chain.860 * 861 * Fee payment on the destination side is made from the asset in the `assets` vector of862 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,863 * with all fees taken as needed from the asset.864 * 865 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.866 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send867 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.868 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be869 * an `AccountId32` value.870 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the871 * `dest` side. May not be empty.872 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay873 * fees.874 **/875 teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;876 /**877 * Generic tx878 **/879 [key: string]: SubmittableExtrinsicFunction<ApiType>;880 };881 preimage: {882 /**883 * Register a preimage on-chain.884 * 885 * If the preimage was previously requested, no fees or deposits are taken for providing886 * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.887 **/888 notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;889 /**890 * Request a preimage be uploaded to the chain without paying any fees or deposits.891 * 892 * If the preimage requests has already been provided on-chain, we unreserve any deposit893 * a user may have paid, and take the control of the preimage out of their hands.894 **/895 requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;896 /**897 * Clear an unrequested preimage from the runtime storage.898 * 899 * If `len` is provided, then it will be a much cheaper operation.900 * 901 * - `hash`: The hash of the preimage to be removed from the store.902 * - `len`: The length of the preimage of `hash`.903 **/904 unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;905 /**906 * Clear a previously made request for a preimage.907 * 908 * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.909 **/910 unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;911 /**912 * Generic tx913 **/914 [key: string]: SubmittableExtrinsicFunction<ApiType>;915 };916 session: {917 /**918 * Removes any session key(s) of the function caller.919 * 920 * This doesn't take effect until the next session.921 * 922 * The dispatch origin of this function must be Signed and the account must be either be923 * convertible to a validator ID using the chain's typical addressing system (this usually924 * means being a controller account) or directly convertible into a validator ID (which925 * usually means being a stash account).926 * 927 * # <weight>928 * - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length929 * of `T::Keys::key_ids()` which is fixed.930 * - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`931 * - DbWrites: `NextKeys`, `origin account`932 * - DbWrites per key id: `KeyOwner`933 * # </weight>934 **/935 purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;936 /**937 * Sets the session key(s) of the function caller to `keys`.938 * Allows an account to set its session key prior to becoming a validator.939 * This doesn't take effect until the next session.940 * 941 * The dispatch origin of this function must be signed.942 * 943 * # <weight>944 * - Complexity: `O(1)`. Actual cost depends on the number of length of945 * `T::Keys::key_ids()` which is fixed.946 * - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`947 * - DbWrites: `origin account`, `NextKeys`948 * - DbReads per key id: `KeyOwner`949 * - DbWrites per key id: `KeyOwner`950 * # </weight>951 **/952 setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;953 /**954 * Generic tx955 **/956 [key: string]: SubmittableExtrinsicFunction<ApiType>;957 };958 structure: {959 /**960 * Generic tx961 **/962 [key: string]: SubmittableExtrinsicFunction<ApiType>;963 };964 sudo: {965 /**966 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo967 * key.968 * 969 * The dispatch origin for this call must be _Signed_.970 * 971 * # <weight>972 * - O(1).973 * - Limited storage reads.974 * - One DB change.975 * # </weight>976 **/977 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;978 /**979 * Authenticates the sudo key and dispatches a function call with `Root` origin.980 * 981 * The dispatch origin for this call must be _Signed_.982 * 983 * # <weight>984 * - O(1).985 * - Limited storage reads.986 * - One DB write (event).987 * - Weight of derivative `call` execution + 10,000.988 * # </weight>989 **/990 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;991 /**992 * Authenticates the sudo key and dispatches a function call with `Signed` origin from993 * a given account.994 * 995 * The dispatch origin for this call must be _Signed_.996 * 997 * # <weight>998 * - O(1).999 * - Limited storage reads.1000 * - One DB write (event).1001 * - Weight of derivative `call` execution + 10,000.1002 * # </weight>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 * # <weight>1013 * - O(1).1014 * - The weight of this call is defined by the caller.1015 * # </weight>1016 **/1017 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;1018 /**1019 * Generic tx1020 **/1021 [key: string]: SubmittableExtrinsicFunction<ApiType>;1022 };1023 system: {1024 /**1025 * Kill all storage items with a key that starts with the given prefix.1026 * 1027 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1028 * the prefix we are removing to accurately calculate the weight of this function.1029 **/1030 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1031 /**1032 * Kill some items from storage.1033 **/1034 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1035 /**1036 * Make some on-chain remark.1037 * 1038 * # <weight>1039 * - `O(1)`1040 * # </weight>1041 **/1042 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1043 /**1044 * Make some on-chain remark and emit event.1045 **/1046 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1047 /**1048 * Set the new runtime code.1049 * 1050 * # <weight>1051 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`1052 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is1053 * expensive).1054 * - 1 storage write (codec `O(C)`).1055 * - 1 digest item.1056 * - 1 event.1057 * The weight of this function is dependent on the runtime, but generally this is very1058 * expensive. We will treat this as a full block.1059 * # </weight>1060 **/1061 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1062 /**1063 * Set the new runtime code without doing any checks of the given `code`.1064 * 1065 * # <weight>1066 * - `O(C)` where `C` length of `code`1067 * - 1 storage write (codec `O(C)`).1068 * - 1 digest item.1069 * - 1 event.1070 * The weight of this function is dependent on the runtime. We will treat this as a full1071 * block. # </weight>1072 **/1073 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1074 /**1075 * Set the number of pages in the WebAssembly environment's heap.1076 **/1077 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1078 /**1079 * Set some items of storage.1080 **/1081 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1082 /**1083 * Generic tx1084 **/1085 [key: string]: SubmittableExtrinsicFunction<ApiType>;1086 };1087 testUtils: {1088 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1089 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1090 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1091 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1092 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1093 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1094 /**1095 * Generic tx1096 **/1097 [key: string]: SubmittableExtrinsicFunction<ApiType>;1098 };1099 timestamp: {1100 /**1101 * Set the current time.1102 * 1103 * This call should be invoked exactly once per block. It will panic at the finalization1104 * phase, if this call hasn't been invoked by that time.1105 * 1106 * The timestamp should be greater than the previous one by the amount specified by1107 * `MinimumPeriod`.1108 * 1109 * The dispatch origin for this call must be `Inherent`.1110 * 1111 * # <weight>1112 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1113 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1114 * `on_finalize`)1115 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1116 * # </weight>1117 **/1118 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1119 /**1120 * Generic tx1121 **/1122 [key: string]: SubmittableExtrinsicFunction<ApiType>;1123 };1124 tokens: {1125 /**1126 * Exactly as `transfer`, except the origin must be root and the source1127 * account may be specified.1128 * 1129 * The dispatch origin for this call must be _Root_.1130 * 1131 * - `source`: The sender of the transfer.1132 * - `dest`: The recipient of the transfer.1133 * - `currency_id`: currency type.1134 * - `amount`: free balance amount to tranfer.1135 **/1136 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>]>;1137 /**1138 * Set the balances of a given account.1139 * 1140 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1141 * will also decrease the total issuance of the system1142 * (`TotalIssuance`). If the new free or reserved balance is below the1143 * existential deposit, it will reap the `AccountInfo`.1144 * 1145 * The dispatch origin for this call is `root`.1146 **/1147 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>]>;1148 /**1149 * Transfer some liquid free balance to another account.1150 * 1151 * `transfer` will set the `FreeBalance` of the sender and receiver.1152 * It will decrease the total issuance of the system by the1153 * `TransferFee`. If the sender's account is below the existential1154 * deposit as a result of the transfer, the account will be reaped.1155 * 1156 * The dispatch origin for this call must be `Signed` by the1157 * transactor.1158 * 1159 * - `dest`: The recipient of the transfer.1160 * - `currency_id`: currency type.1161 * - `amount`: free balance amount to tranfer.1162 **/1163 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>]>;1164 /**1165 * Transfer all remaining balance to the given account.1166 * 1167 * NOTE: This function only attempts to transfer _transferable_1168 * balances. This means that any locked, reserved, or existential1169 * deposits (when `keep_alive` is `true`), will not be transferred by1170 * this function. To ensure that this function results in a killed1171 * account, you might need to prepare the account by removing any1172 * reference counters, storage deposits, etc...1173 * 1174 * The dispatch origin for this call must be `Signed` by the1175 * transactor.1176 * 1177 * - `dest`: The recipient of the transfer.1178 * - `currency_id`: currency type.1179 * - `keep_alive`: A boolean to determine if the `transfer_all`1180 * operation should send all of the funds the account has, causing1181 * the sender account to be killed (false), or transfer everything1182 * except at least the existential deposit, which will guarantee to1183 * keep the sender account alive (true).1184 **/1185 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]>;1186 /**1187 * Same as the [`transfer`] call, but with a check that the transfer1188 * will not kill the origin account.1189 * 1190 * 99% of the time you want [`transfer`] instead.1191 * 1192 * The dispatch origin for this call must be `Signed` by the1193 * transactor.1194 * 1195 * - `dest`: The recipient of the transfer.1196 * - `currency_id`: currency type.1197 * - `amount`: free balance amount to tranfer.1198 **/1199 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>]>;1200 /**1201 * Generic tx1202 **/1203 [key: string]: SubmittableExtrinsicFunction<ApiType>;1204 };1205 treasury: {1206 /**1207 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1208 * and the original deposit will be returned.1209 * 1210 * May only be called from `T::ApproveOrigin`.1211 * 1212 * # <weight>1213 * - Complexity: O(1).1214 * - DbReads: `Proposals`, `Approvals`1215 * - DbWrite: `Approvals`1216 * # </weight>1217 **/1218 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1219 /**1220 * Put forward a suggestion for spending. A deposit proportional to the value1221 * is reserved and slashed if the proposal is rejected. It is returned once the1222 * proposal is awarded.1223 * 1224 * # <weight>1225 * - Complexity: O(1)1226 * - DbReads: `ProposalCount`, `origin account`1227 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1228 * # </weight>1229 **/1230 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]>;1231 /**1232 * Reject a proposed spend. The original deposit will be slashed.1233 * 1234 * May only be called from `T::RejectOrigin`.1235 * 1236 * # <weight>1237 * - Complexity: O(1)1238 * - DbReads: `Proposals`, `rejected proposer account`1239 * - DbWrites: `Proposals`, `rejected proposer account`1240 * # </weight>1241 **/1242 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1243 /**1244 * Force a previously approved proposal to be removed from the approval queue.1245 * The original deposit will no longer be returned.1246 * 1247 * May only be called from `T::RejectOrigin`.1248 * - `proposal_id`: The index of a proposal1249 * 1250 * # <weight>1251 * - Complexity: O(A) where `A` is the number of approvals1252 * - Db reads and writes: `Approvals`1253 * # </weight>1254 * 1255 * Errors:1256 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1257 * i.e., the proposal has not been approved. This could also mean the proposal does not1258 * exist altogether, thus there is no way it would have been approved in the first place.1259 **/1260 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1261 /**1262 * Propose and approve a spend of treasury funds.1263 * 1264 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1265 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1266 * - `beneficiary`: The destination account for the transfer.1267 * 1268 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1269 * beneficiary.1270 **/1271 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]>;1272 /**1273 * Generic tx1274 **/1275 [key: string]: SubmittableExtrinsicFunction<ApiType>;1276 };1277 unique: {1278 /**1279 * Add an admin to a collection.1280 * 1281 * NFT Collection can be controlled by multiple admin addresses1282 * (some which can also be servers, for example). Admins can issue1283 * and burn NFTs, as well as add and remove other admins,1284 * but cannot change NFT or Collection ownership.1285 * 1286 * # Permissions1287 * 1288 * * Collection owner1289 * * Collection admin1290 * 1291 * # Arguments1292 * 1293 * * `collection_id`: ID of the Collection to add an admin for.1294 * * `new_admin`: Address of new admin to add.1295 **/1296 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1297 /**1298 * Add an address to allow list.1299 * 1300 * # Permissions1301 * 1302 * * Collection owner1303 * * Collection admin1304 * 1305 * # Arguments1306 * 1307 * * `collection_id`: ID of the modified collection.1308 * * `address`: ID of the address to be added to the allowlist.1309 **/1310 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1311 /**1312 * Allow a non-permissioned address to transfer or burn an item.1313 * 1314 * # Permissions1315 * 1316 * * Collection owner1317 * * Collection admin1318 * * Current item owner1319 * 1320 * # Arguments1321 * 1322 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1323 * * `collection_id`: ID of the collection the item belongs to.1324 * * `item_id`: ID of the item transactions on which are now approved.1325 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1326 * Set to 0 to revoke the approval.1327 **/1328 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]>;1329 /**1330 * Allow a non-permissioned address to transfer or burn an item from owner's eth mirror.1331 * 1332 * # Permissions1333 * 1334 * * Collection owner1335 * * Collection admin1336 * * Current item owner1337 * 1338 * # Arguments1339 * 1340 * * `from`: Owner's account eth mirror1341 * * `to`: Account to be approved to make specific transactions on non-owned tokens.1342 * * `collection_id`: ID of the collection the item belongs to.1343 * * `item_id`: ID of the item transactions on which are now approved.1344 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1345 * Set to 0 to revoke the approval.1346 **/1347 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]>;1348 /**1349 * Destroy a token on behalf of the owner as a non-owner account.1350 * 1351 * See also: [`approve`][`Pallet::approve`].1352 * 1353 * After this method executes, one approval is removed from the total so that1354 * the approved address will not be able to transfer this item again from this owner.1355 * 1356 * # Permissions1357 * 1358 * * Collection owner1359 * * Collection admin1360 * * Current token owner1361 * * Address approved by current item owner1362 * 1363 * # Arguments1364 * 1365 * * `from`: The owner of the burning item.1366 * * `collection_id`: ID of the collection to which the item belongs.1367 * * `item_id`: ID of item to burn.1368 * * `value`: Number of pieces to burn.1369 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1370 * * Fungible Mode: The desired number of pieces to burn.1371 * * Re-Fungible Mode: The desired number of pieces to burn.1372 **/1373 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]>;1374 /**1375 * Destroy an item.1376 * 1377 * # Permissions1378 * 1379 * * Collection owner1380 * * Collection admin1381 * * Current item owner1382 * 1383 * # Arguments1384 * 1385 * * `collection_id`: ID of the collection to which the item belongs.1386 * * `item_id`: ID of item to burn.1387 * * `value`: Number of pieces of the item to destroy.1388 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1389 * * Fungible Mode: The desired number of pieces to burn.1390 * * Re-Fungible Mode: The desired number of pieces to burn.1391 **/1392 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1393 /**1394 * Change the owner of the collection.1395 * 1396 * # Permissions1397 * 1398 * * Collection owner1399 * 1400 * # Arguments1401 * 1402 * * `collection_id`: ID of the modified collection.1403 * * `new_owner`: ID of the account that will become the owner.1404 **/1405 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1406 /**1407 * Confirm own sponsorship of a collection, becoming the sponsor.1408 * 1409 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1410 * Sponsor can pay the fees of a transaction instead of the sender,1411 * but only within specified limits.1412 * 1413 * # Permissions1414 * 1415 * * Sponsor-to-be1416 * 1417 * # Arguments1418 * 1419 * * `collection_id`: ID of the collection with the pending sponsor.1420 **/1421 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1422 /**1423 * Create a collection of tokens.1424 * 1425 * Each Token may have multiple properties encoded as an array of bytes1426 * of certain length. The initial owner of the collection is set1427 * to the address that signed the transaction and can be changed later.1428 * 1429 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1430 * 1431 * # Permissions1432 * 1433 * * Anyone - becomes the owner of the new collection.1434 * 1435 * # Arguments1436 * 1437 * * `collection_name`: Wide-character string with collection name1438 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1439 * * `collection_description`: Wide-character string with collection description1440 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1441 * * `token_prefix`: Byte string containing the token prefix to mark a collection1442 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1443 * * `mode`: Type of items stored in the collection and type dependent data.1444 * 1445 * returns collection ID1446 * 1447 * Deprecated: `create_collection_ex` is more up-to-date and advanced, prefer it instead.1448 **/1449 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]>;1450 /**1451 * Create a collection with explicit parameters.1452 * 1453 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1454 * 1455 * # Permissions1456 * 1457 * * Anyone - becomes the owner of the new collection.1458 * 1459 * # Arguments1460 * 1461 * * `data`: Explicit data of a collection used for its creation.1462 **/1463 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]>;1464 /**1465 * Mint an item within a collection.1466 * 1467 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1468 * 1469 * # Permissions1470 * 1471 * * Collection owner1472 * * Collection admin1473 * * Anyone if1474 * * Allow List is enabled, and1475 * * Address is added to allow list, and1476 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1477 * 1478 * # Arguments1479 * 1480 * * `collection_id`: ID of the collection to which an item would belong.1481 * * `owner`: Address of the initial owner of the item.1482 * * `data`: Token data describing the item to store on chain.1483 **/1484 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]>;1485 /**1486 * Create multiple items within a collection.1487 * 1488 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1489 * 1490 * # Permissions1491 * 1492 * * Collection owner1493 * * Collection admin1494 * * Anyone if1495 * * Allow List is enabled, and1496 * * Address is added to the allow list, and1497 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1498 * 1499 * # Arguments1500 * 1501 * * `collection_id`: ID of the collection to which the tokens would belong.1502 * * `owner`: Address of the initial owner of the tokens.1503 * * `items_data`: Vector of data describing each item to be created.1504 **/1505 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>]>;1506 /**1507 * Create multiple items within a collection with explicitly specified initial parameters.1508 * 1509 * # Permissions1510 * 1511 * * Collection owner1512 * * Collection admin1513 * * Anyone if1514 * * Allow List is enabled, and1515 * * Address is added to allow list, and1516 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1517 * 1518 * # Arguments1519 * 1520 * * `collection_id`: ID of the collection to which the tokens would belong.1521 * * `data`: Explicit item creation data.1522 **/1523 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1524 /**1525 * Delete specified collection properties.1526 * 1527 * # Permissions1528 * 1529 * * Collection Owner1530 * * Collection Admin1531 * 1532 * # Arguments1533 * 1534 * * `collection_id`: ID of the modified collection.1535 * * `property_keys`: Vector of keys of the properties to be deleted.1536 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1537 **/1538 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1539 /**1540 * Delete specified token properties. Currently properties only work with NFTs.1541 * 1542 * # Permissions1543 * 1544 * * Depends on collection's token property permissions and specified property mutability:1545 * * Collection owner1546 * * Collection admin1547 * * Token owner1548 * 1549 * # Arguments1550 * 1551 * * `collection_id`: ID of the collection to which the token belongs.1552 * * `token_id`: ID of the modified token.1553 * * `property_keys`: Vector of keys of the properties to be deleted.1554 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1555 **/1556 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1557 /**1558 * Destroy a collection if no tokens exist within.1559 * 1560 * # Permissions1561 * 1562 * * Collection owner1563 * 1564 * # Arguments1565 * 1566 * * `collection_id`: Collection to destroy.1567 **/1568 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1569 /**1570 * Repairs a collection if the data was somehow corrupted.1571 * 1572 * # Arguments1573 * 1574 * * `collection_id`: ID of the collection to repair.1575 **/1576 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1577 /**1578 * Repairs a token if the data was somehow corrupted.1579 * 1580 * # Arguments1581 * 1582 * * `collection_id`: ID of the collection the item belongs to.1583 * * `item_id`: ID of the item.1584 **/1585 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1586 /**1587 * Remove admin of a collection.1588 * 1589 * An admin address can remove itself. List of admins may become empty,1590 * in which case only Collection Owner will be able to add an Admin.1591 * 1592 * # Permissions1593 * 1594 * * Collection owner1595 * * Collection admin1596 * 1597 * # Arguments1598 * 1599 * * `collection_id`: ID of the collection to remove the admin for.1600 * * `account_id`: Address of the admin to remove.1601 **/1602 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1603 /**1604 * Remove a collection's a sponsor, making everyone pay for their own transactions.1605 * 1606 * # Permissions1607 * 1608 * * Collection owner1609 * 1610 * # Arguments1611 * 1612 * * `collection_id`: ID of the collection with the sponsor to remove.1613 **/1614 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1615 /**1616 * Remove an address from allow list.1617 * 1618 * # Permissions1619 * 1620 * * Collection owner1621 * * Collection admin1622 * 1623 * # Arguments1624 * 1625 * * `collection_id`: ID of the modified collection.1626 * * `address`: ID of the address to be removed from the allowlist.1627 **/1628 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1629 /**1630 * Re-partition a refungible token, while owning all of its parts/pieces.1631 * 1632 * # Permissions1633 * 1634 * * Token owner (must own every part)1635 * 1636 * # Arguments1637 * 1638 * * `collection_id`: ID of the collection the RFT belongs to.1639 * * `token_id`: ID of the RFT.1640 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1641 **/1642 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1643 /**1644 * Sets or unsets the approval of a given operator.1645 * 1646 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1647 * 1648 * # Arguments1649 * 1650 * * `owner`: Token owner1651 * * `operator`: Operator1652 * * `approve`: Should operator status be granted or revoked?1653 **/1654 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1655 /**1656 * Set specific limits of a collection. Empty, or None fields mean chain default.1657 * 1658 * # Permissions1659 * 1660 * * Collection owner1661 * * Collection admin1662 * 1663 * # Arguments1664 * 1665 * * `collection_id`: ID of the modified collection.1666 * * `new_limit`: New limits of the collection. Fields that are not set (None)1667 * will not overwrite the old ones.1668 **/1669 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]>;1670 /**1671 * Set specific permissions of a collection. Empty, or None fields mean chain default.1672 * 1673 * # Permissions1674 * 1675 * * Collection owner1676 * * Collection admin1677 * 1678 * # Arguments1679 * 1680 * * `collection_id`: ID of the modified collection.1681 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1682 * will not overwrite the old ones.1683 **/1684 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1685 /**1686 * Add or change collection properties.1687 * 1688 * # Permissions1689 * 1690 * * Collection owner1691 * * Collection admin1692 * 1693 * # Arguments1694 * 1695 * * `collection_id`: ID of the modified collection.1696 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1697 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1698 **/1699 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1700 /**1701 * Set (invite) a new collection sponsor.1702 * 1703 * If successful, confirmation from the sponsor-to-be will be pending.1704 * 1705 * # Permissions1706 * 1707 * * Collection owner1708 * * Collection admin1709 * 1710 * # Arguments1711 * 1712 * * `collection_id`: ID of the modified collection.1713 * * `new_sponsor`: ID of the account of the sponsor-to-be.1714 **/1715 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1716 /**1717 * Add or change token properties according to collection's permissions.1718 * Currently properties only work with NFTs.1719 * 1720 * # Permissions1721 * 1722 * * Depends on collection's token property permissions and specified property mutability:1723 * * Collection owner1724 * * Collection admin1725 * * Token owner1726 * 1727 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1728 * 1729 * # Arguments1730 * 1731 * * `collection_id: ID of the collection to which the token belongs.1732 * * `token_id`: ID of the modified token.1733 * * `properties`: Vector of key-value pairs stored as the token's metadata.1734 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1735 **/1736 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>]>;1737 /**1738 * Add or change token property permissions of a collection.1739 * 1740 * Without a permission for a particular key, a property with that key1741 * cannot be created in a token.1742 * 1743 * # Permissions1744 * 1745 * * Collection owner1746 * * Collection admin1747 * 1748 * # Arguments1749 * 1750 * * `collection_id`: ID of the modified collection.1751 * * `property_permissions`: Vector of permissions for property keys.1752 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1753 **/1754 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1755 /**1756 * Completely allow or disallow transfers for a particular collection.1757 * 1758 * # Permissions1759 * 1760 * * Collection owner1761 * 1762 * # Arguments1763 * 1764 * * `collection_id`: ID of the collection.1765 * * `value`: New value of the flag, are transfers allowed?1766 **/1767 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1768 /**1769 * Change ownership of the token.1770 * 1771 * # Permissions1772 * 1773 * * Collection owner1774 * * Collection admin1775 * * Current token owner1776 * 1777 * # Arguments1778 * 1779 * * `recipient`: Address of token recipient.1780 * * `collection_id`: ID of the collection the item belongs to.1781 * * `item_id`: ID of the item.1782 * * Non-Fungible Mode: Required.1783 * * Fungible Mode: Ignored.1784 * * Re-Fungible Mode: Required.1785 * 1786 * * `value`: Amount to transfer.1787 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1788 * * Fungible Mode: The desired number of pieces to transfer.1789 * * Re-Fungible Mode: The desired number of pieces to transfer.1790 **/1791 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]>;1792 /**1793 * Change ownership of an item on behalf of the owner as a non-owner account.1794 * 1795 * See the [`approve`][`Pallet::approve`] method for additional information.1796 * 1797 * After this method executes, one approval is removed from the total so that1798 * the approved address will not be able to transfer this item again from this owner.1799 * 1800 * # Permissions1801 * 1802 * * Collection owner1803 * * Collection admin1804 * * Current item owner1805 * * Address approved by current item owner1806 * 1807 * # Arguments1808 * 1809 * * `from`: Address that currently owns the token.1810 * * `recipient`: Address of the new token-owner-to-be.1811 * * `collection_id`: ID of the collection the item.1812 * * `item_id`: ID of the item to be transferred.1813 * * `value`: Amount to transfer.1814 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1815 * * Fungible Mode: The desired number of pieces to transfer.1816 * * Re-Fungible Mode: The desired number of pieces to transfer.1817 **/1818 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]>;1819 /**1820 * Generic tx1821 **/1822 [key: string]: SubmittableExtrinsicFunction<ApiType>;1823 };1824 vesting: {1825 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1826 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1827 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>]>;1828 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]>;1829 /**1830 * Generic tx1831 **/1832 [key: string]: SubmittableExtrinsicFunction<ApiType>;1833 };1834 xcmpQueue: {1835 /**1836 * Resumes all XCM executions for the XCMP queue.1837 * 1838 * Note that this function doesn't change the status of the in/out bound channels.1839 * 1840 * - `origin`: Must pass `ControllerOrigin`.1841 **/1842 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1843 /**1844 * Services a single overweight XCM.1845 * 1846 * - `origin`: Must pass `ExecuteOverweightOrigin`.1847 * - `index`: The index of the overweight XCM to service1848 * - `weight_limit`: The amount of weight that XCM execution may take.1849 * 1850 * Errors:1851 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1852 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1853 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1854 * 1855 * Events:1856 * - `OverweightServiced`: On success.1857 **/1858 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1859 /**1860 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1861 * 1862 * - `origin`: Must pass `ControllerOrigin`.1863 **/1864 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1865 /**1866 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1867 * messages from the channel.1868 * 1869 * - `origin`: Must pass `Root`.1870 * - `new`: Desired value for `QueueConfigData.drop_threshold`1871 **/1872 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1873 /**1874 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1875 * message sending may recommence after it has been suspended.1876 * 1877 * - `origin`: Must pass `Root`.1878 * - `new`: Desired value for `QueueConfigData.resume_threshold`1879 **/1880 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1881 /**1882 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1883 * suspend their sending.1884 * 1885 * - `origin`: Must pass `Root`.1886 * - `new`: Desired value for `QueueConfigData.suspend_value`1887 **/1888 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1889 /**1890 * Overwrites the amount of remaining weight under which we stop processing messages.1891 * 1892 * - `origin`: Must pass `Root`.1893 * - `new`: Desired value for `QueueConfigData.threshold_weight`1894 **/1895 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1896 /**1897 * Overwrites the speed to which the available weight approaches the maximum weight.1898 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1899 * 1900 * - `origin`: Must pass `Root`.1901 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1902 **/1903 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1904 /**1905 * Overwrite the maximum amount of weight any individual message may consume.1906 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1907 * 1908 * - `origin`: Must pass `Root`.1909 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1910 **/1911 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1912 /**1913 * Generic tx1914 **/1915 [key: string]: SubmittableExtrinsicFunction<ApiType>;1916 };1917 xTokens: {1918 /**1919 * Transfer native currencies.1920 * 1921 * `dest_weight_limit` is the weight for XCM execution on the dest1922 * chain, and it would be charged from the transferred assets. If set1923 * below requirements, the execution may fail and assets wouldn't be1924 * received.1925 * 1926 * It's a no-op if any error on local XCM execution or message sending.1927 * Note sending assets out per se doesn't guarantee they would be1928 * received. Receiving depends on if the XCM message could be delivered1929 * by the network, and if the receiving chain would handle1930 * messages correctly.1931 **/1932 transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1933 /**1934 * Transfer `MultiAsset`.1935 * 1936 * `dest_weight_limit` is the weight for XCM execution on the dest1937 * chain, and it would be charged from the transferred assets. If set1938 * below requirements, the execution may fail and assets wouldn't be1939 * received.1940 * 1941 * It's a no-op if any error on local XCM execution or message sending.1942 * Note sending assets out per se doesn't guarantee they would be1943 * received. Receiving depends on if the XCM message could be delivered1944 * by the network, and if the receiving chain would handle1945 * messages correctly.1946 **/1947 transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1948 /**1949 * Transfer several `MultiAsset` specifying the item to be used as fee1950 * 1951 * `dest_weight_limit` is the weight for XCM execution on the dest1952 * chain, and it would be charged from the transferred assets. If set1953 * below requirements, the execution may fail and assets wouldn't be1954 * received.1955 * 1956 * `fee_item` is index of the MultiAssets that we want to use for1957 * payment1958 * 1959 * It's a no-op if any error on local XCM execution or message sending.1960 * Note sending assets out per se doesn't guarantee they would be1961 * received. Receiving depends on if the XCM message could be delivered1962 * by the network, and if the receiving chain would handle1963 * messages correctly.1964 **/1965 transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1966 /**1967 * Transfer `MultiAsset` specifying the fee and amount as separate.1968 * 1969 * `dest_weight_limit` is the weight for XCM execution on the dest1970 * chain, and it would be charged from the transferred assets. If set1971 * below requirements, the execution may fail and assets wouldn't be1972 * received.1973 * 1974 * `fee` is the multiasset to be spent to pay for execution in1975 * destination chain. Both fee and amount will be subtracted form the1976 * callers balance For now we only accept fee and asset having the same1977 * `MultiLocation` id.1978 * 1979 * If `fee` is not high enough to cover for the execution costs in the1980 * destination chain, then the assets will be trapped in the1981 * destination chain1982 * 1983 * It's a no-op if any error on local XCM execution or message sending.1984 * Note sending assets out per se doesn't guarantee they would be1985 * received. Receiving depends on if the XCM message could be delivered1986 * by the network, and if the receiving chain would handle1987 * messages correctly.1988 **/1989 transferMultiassetWithFee: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, fee: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV2WeightLimit]>;1990 /**1991 * Transfer several currencies specifying the item to be used as fee1992 * 1993 * `dest_weight_limit` is the weight for XCM execution on the dest1994 * chain, and it would be charged from the transferred assets. If set1995 * below requirements, the execution may fail and assets wouldn't be1996 * received.1997 * 1998 * `fee_item` is index of the currencies tuple that we want to use for1999 * payment2000 * 2001 * It's a no-op if any error on local XCM execution or message sending.2002 * Note sending assets out per se doesn't guarantee they would be2003 * received. Receiving depends on if the XCM message could be delivered2004 * by the network, and if the receiving chain would handle2005 * messages correctly.2006 **/2007 transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>> | ([PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, XcmV2WeightLimit]>;2008 /**2009 * Transfer native currencies specifying the fee and amount as2010 * separate.2011 * 2012 * `dest_weight_limit` is the weight for XCM execution on the dest2013 * chain, and it would be charged from the transferred assets. If set2014 * below requirements, the execution may fail and assets wouldn't be2015 * received.2016 * 2017 * `fee` is the amount to be spent to pay for execution in destination2018 * chain. Both fee and amount will be subtracted form the callers2019 * balance.2020 * 2021 * If `fee` is not high enough to cover for the execution costs in the2022 * destination chain, then the assets will be trapped in the2023 * destination chain2024 * 2025 * It's a no-op if any error on local XCM execution or message sending.2026 * Note sending assets out per se doesn't guarantee they would be2027 * received. Receiving depends on if the XCM message could be delivered2028 * by the network, and if the receiving chain would handle2029 * messages correctly.2030 **/2031 transferWithFee: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, XcmV2WeightLimit]>;2032 /**2033 * Generic tx2034 **/2035 [key: string]: SubmittableExtrinsicFunction<ApiType>;2036 };2037 } // AugmentedSubmittables2038} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts109.1 KiBsourcehistory