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, PalletStateTrieMigrationMigrationLimits, PalletStateTrieMigrationMigrationTask, PalletStateTrieMigrationProgress, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV3MultiLocation, XcmV3WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1415export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;16export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;17export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1819declare module '@polkadot/api-base/types/submittable' {20 interface AugmentedSubmittables<ApiType extends ApiTypes> {21 appPromotion: {22 /**23 * Called for blocks that, for some reason, have not been unstacked24 * 25 * # Permissions26 * 27 * * Sudo28 * 29 * # Arguments30 * 31 * * `origin`: Must be `Root`.32 * * `pending_blocks`: Block numbers that will be processed.33 **/34 forceUnstake: AugmentedSubmittable<(pendingBlocks: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<u32>]>;35 /**36 * Recalculates interest for the specified number of stakers.37 * If all stakers are not recalculated, the next call of the extrinsic38 * will continue the recalculation, from those stakers for whom this39 * was not perform in last call.40 * 41 * # Permissions42 * 43 * * Pallet admin44 * 45 * # Arguments46 * 47 * * `stakers_number`: the number of stakers for which recalculation will be performed48 **/49 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;50 /**51 * Sets an address as the the admin.52 * 53 * # Permissions54 * 55 * * Sudo56 * 57 * # Arguments58 * 59 * * `admin`: account of the new admin.60 **/61 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;62 /**63 * Sets the pallet to be the sponsor for the collection.64 * 65 * # Permissions66 * 67 * * Pallet admin68 * 69 * # Arguments70 * 71 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`72 **/73 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;74 /**75 * Sets the pallet to be the sponsor for the contract.76 * 77 * # Permissions78 * 79 * * Pallet admin80 * 81 * # Arguments82 * 83 * * `contract_id`: the contract address that will be sponsored by `pallet_id`84 **/85 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;86 /**87 * Stakes the amount of native tokens.88 * Sets `amount` to the locked state.89 * The maximum number of stakes for a staker is 10.90 * 91 * # Arguments92 * 93 * * `amount`: in native tokens.94 **/95 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;96 /**97 * Removes the pallet as the sponsor for the collection.98 * Returns [`NoPermission`][`Error::NoPermission`]99 * if the pallet wasn't the sponsor.100 * 101 * # Permissions102 * 103 * * Pallet admin104 * 105 * # Arguments106 * 107 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`108 **/109 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;110 /**111 * Removes the pallet as the sponsor for the contract.112 * Returns [`NoPermission`][`Error::NoPermission`]113 * if the pallet wasn't the sponsor.114 * 115 * # Permissions116 * 117 * * Pallet admin118 * 119 * # Arguments120 * 121 * * `contract_id`: the contract address that is sponsored by `pallet_id`122 **/123 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;124 /**125 * Unstakes all stakes.126 * After the end of `PendingInterval` this sum becomes completely127 * free for further use.128 **/129 unstakeAll: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;130 /**131 * Unstakes the amount of balance for the staker.132 * After the end of `PendingInterval` this sum becomes completely133 * free for further use.134 * 135 * # Arguments136 * 137 * * `staker`: staker account.138 * * `amount`: amount of unstaked funds.139 **/140 unstakePartial: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;141 /**142 * Generic tx143 **/144 [key: string]: SubmittableExtrinsicFunction<ApiType>;145 };146 balances: {147 /**148 * Set the regular balance of a given account.149 * 150 * The dispatch origin for this call is `root`.151 **/152 forceSetBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;153 /**154 * Exactly as `transfer_allow_death`, except the origin must be root and the source account155 * may be specified.156 **/157 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>]>;158 /**159 * Unreserve some balance from a user by force.160 * 161 * Can only be called by ROOT.162 **/163 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;164 /**165 * Set the regular balance of a given account; it also takes a reserved balance but this166 * must be the same as the account's current reserved balance.167 * 168 * The dispatch origin for this call is `root`.169 * 170 * WARNING: This call is DEPRECATED! Use `force_set_balance` instead.171 **/172 setBalanceDeprecated: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, oldReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;173 /**174 * Alias for `transfer_allow_death`, provided only for name-wise compatibility.175 * 176 * WARNING: DEPRECATED! Will be released in approximately 3 months.177 **/178 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>]>;179 /**180 * Transfer the entire transferable balance from the caller account.181 * 182 * NOTE: This function only attempts to transfer _transferable_ balances. This means that183 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be184 * transferred by this function. To ensure that this function results in a killed account,185 * you might need to prepare the account by removing any reference counters, storage186 * deposits, etc...187 * 188 * The dispatch origin of this call must be Signed.189 * 190 * - `dest`: The recipient of the transfer.191 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all192 * of the funds the account has, causing the sender account to be killed (false), or193 * transfer everything except at least the existential deposit, which will guarantee to194 * keep the sender account alive (true).195 **/196 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;197 /**198 * Transfer some liquid free balance to another account.199 * 200 * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver.201 * If the sender's account is below the existential deposit as a result202 * of the transfer, the account will be reaped.203 * 204 * The dispatch origin for this call must be `Signed` by the transactor.205 **/206 transferAllowDeath: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;207 /**208 * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not209 * kill the origin account.210 * 211 * 99% of the time you want [`transfer_allow_death`] instead.212 * 213 * [`transfer_allow_death`]: struct.Pallet.html#method.transfer214 **/215 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>]>;216 /**217 * Upgrade a specified account.218 * 219 * - `origin`: Must be `Signed`.220 * - `who`: The account to be upgraded.221 * 222 * This will waive the transaction fee if at least all but 10% of the accounts needed to223 * be upgraded. (We let some not have to be upgraded just in order to allow for the224 * possibililty of churn).225 **/226 upgradeAccounts: AugmentedSubmittable<(who: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;227 /**228 * Generic tx229 **/230 [key: string]: SubmittableExtrinsicFunction<ApiType>;231 };232 collatorSelection: {233 /**234 * Add a collator to the list of invulnerable (fixed) collators.235 **/236 addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;237 /**238 * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.239 * Note that the collator can only leave on session change.240 * The `LicenseBond` will be unreserved and returned immediately.241 * 242 * This call is, of course, not applicable to `Invulnerable` collators.243 **/244 forceReleaseLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;245 /**246 * Purchase a license on block collation for this account.247 * It does not make it a collator candidate, use `onboard` afterward. The account must248 * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.249 * 250 * This call is not available to `Invulnerable` collators.251 **/252 getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;253 /**254 * Deregister `origin` as a collator candidate. Note that the collator can only leave on255 * session change. The license to `onboard` later at any other time will remain.256 **/257 offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;258 /**259 * Register this account as a candidate for collators for next sessions.260 * The account must already hold a license, and cannot offboard immediately during a session.261 * 262 * This call is not available to `Invulnerable` collators.263 **/264 onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;265 /**266 * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.267 * 268 * This call is not available to `Invulnerable` collators.269 **/270 releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;271 /**272 * Remove a collator from the list of invulnerable (fixed) collators.273 **/274 removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;275 /**276 * Generic tx277 **/278 [key: string]: SubmittableExtrinsicFunction<ApiType>;279 };280 configuration: {281 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;282 setCollatorSelectionDesiredCollators: AugmentedSubmittable<(max: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;283 setCollatorSelectionKickThreshold: AugmentedSubmittable<(threshold: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;284 setCollatorSelectionLicenseBond: AugmentedSubmittable<(amount: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u128>]>;285 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;286 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;287 /**288 * Generic tx289 **/290 [key: string]: SubmittableExtrinsicFunction<ApiType>;291 };292 cumulusXcm: {293 /**294 * Generic tx295 **/296 [key: string]: SubmittableExtrinsicFunction<ApiType>;297 };298 dmpQueue: {299 /**300 * Service a single overweight message.301 **/302 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;303 /**304 * Generic tx305 **/306 [key: string]: SubmittableExtrinsicFunction<ApiType>;307 };308 ethereum: {309 /**310 * Transact an Ethereum transaction.311 **/312 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;313 /**314 * Generic tx315 **/316 [key: string]: SubmittableExtrinsicFunction<ApiType>;317 };318 evm: {319 /**320 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.321 **/322 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>]>>]>;323 /**324 * Issue an EVM create operation. This is similar to a contract creation transaction in325 * Ethereum.326 **/327 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>]>>]>;328 /**329 * Issue an EVM create2 operation.330 **/331 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>]>>]>;332 /**333 * Withdraw balance from EVM into currency/balances pallet.334 **/335 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;336 /**337 * Generic tx338 **/339 [key: string]: SubmittableExtrinsicFunction<ApiType>;340 };341 evmContractHelpers: {342 /**343 * Migrate contract to use `SponsoringMode` storage instead of `SelfSponsoring`344 **/345 migrateFromSelfSponsoring: AugmentedSubmittable<(addresses: Vec<H160> | (H160 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<H160>]>;346 /**347 * Generic tx348 **/349 [key: string]: SubmittableExtrinsicFunction<ApiType>;350 };351 evmMigration: {352 /**353 * Start contract migration, inserts contract stub at target address,354 * and marks account as pending, allowing to insert storage355 **/356 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;357 /**358 * Finish contract migration, allows it to be called.359 * It is not possible to alter contract storage via [`Self::set_data`]360 * after this call.361 **/362 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;363 /**364 * Create ethereum events attached to the fake transaction365 **/366 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;367 /**368 * Create substrate events369 **/370 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;371 /**372 * Remove remark compatibility data leftovers373 **/374 removeRmrkData: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;375 /**376 * Insert items into contract storage, this method can be called377 * multiple times378 **/379 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;380 /**381 * Generic tx382 **/383 [key: string]: SubmittableExtrinsicFunction<ApiType>;384 };385 foreignAssets: {386 registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;387 updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;388 /**389 * Generic tx390 **/391 [key: string]: SubmittableExtrinsicFunction<ApiType>;392 };393 identity: {394 /**395 * Add a registrar to the system.396 * 397 * The dispatch origin for this call must be `T::RegistrarOrigin`.398 * 399 * - `account`: the account of the registrar.400 * 401 * Emits `RegistrarAdded` if successful.402 * 403 * # <weight>404 * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).405 * - One storage mutation (codec `O(R)`).406 * - One event.407 * # </weight>408 **/409 addRegistrar: AugmentedSubmittable<(account: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;410 /**411 * Add the given account to the sender's subs.412 * 413 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated414 * to the sender.415 * 416 * The dispatch origin for this call must be _Signed_ and the sender must have a registered417 * sub identity of `sub`.418 **/419 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]>;420 /**421 * Cancel a previous request.422 * 423 * Payment: A previously reserved deposit is returned on success.424 * 425 * The dispatch origin for this call must be _Signed_ and the sender must have a426 * registered identity.427 * 428 * - `reg_index`: The index of the registrar whose judgement is no longer requested.429 * 430 * Emits `JudgementUnrequested` if successful.431 * 432 * # <weight>433 * - `O(R + X)`.434 * - One balance-reserve operation.435 * - One storage mutation `O(R + X)`.436 * - One event437 * # </weight>438 **/439 cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;440 /**441 * Clear an account's identity info and all sub-accounts and return all deposits.442 * 443 * Payment: All reserved balances on the account are returned.444 * 445 * The dispatch origin for this call must be _Signed_ and the sender must have a registered446 * identity.447 * 448 * Emits `IdentityCleared` if successful.449 * 450 * # <weight>451 * - `O(R + S + X)`452 * - where `R` registrar-count (governance-bounded).453 * - where `S` subs-count (hard- and deposit-bounded).454 * - where `X` additional-field-count (deposit-bounded and code-bounded).455 * - One balance-unreserve operation.456 * - `2` storage reads and `S + 2` storage deletions.457 * - One event.458 * # </weight>459 **/460 clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;461 /**462 * Set identities to be associated with the provided accounts as force origin.463 * 464 * This is not meant to operate in tandem with the identity pallet as is,465 * and be instead used to keep identities made and verified externally,466 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.467 **/468 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]>>]>;469 /**470 * Remove identities 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 forceRemoveIdentities: AugmentedSubmittable<(identities: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;477 /**478 * Set sub-identities to be 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 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]>>]>]>>]>;485 /**486 * Remove an account's identity and sub-account information and slash the deposits.487 * 488 * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by489 * `Slash`. Verification request deposits are not returned; they should be cancelled490 * manually using `cancel_request`.491 * 492 * The dispatch origin for this call must match `T::ForceOrigin`.493 * 494 * - `target`: the account whose identity the judgement is upon. This must be an account495 * with a registered identity.496 * 497 * Emits `IdentityKilled` if successful.498 * 499 * # <weight>500 * - `O(R + S + X)`.501 * - One balance-reserve operation.502 * - `S + 2` storage mutations.503 * - One event.504 * # </weight>505 **/506 killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;507 /**508 * Provide a judgement for an account's identity.509 * 510 * The dispatch origin for this call must be _Signed_ and the sender must be the account511 * of the registrar whose index is `reg_index`.512 * 513 * - `reg_index`: the index of the registrar whose judgement is being made.514 * - `target`: the account whose identity the judgement is upon. This must be an account515 * with a registered identity.516 * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.517 * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.518 * 519 * Emits `JudgementGiven` if successful.520 * 521 * # <weight>522 * - `O(R + X)`.523 * - One balance-transfer operation.524 * - Up to one account-lookup operation.525 * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.526 * - One event.527 * # </weight>528 **/529 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]>;530 /**531 * Remove the sender as a sub-account.532 * 533 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated534 * to the sender (*not* the original depositor).535 * 536 * The dispatch origin for this call must be _Signed_ and the sender must have a registered537 * super-identity.538 * 539 * NOTE: This should not normally be used, but is provided in the case that the non-540 * controller of an account is maliciously registered as a sub-account.541 **/542 quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;543 /**544 * Remove the given account from the sender's subs.545 * 546 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated547 * to the sender.548 * 549 * The dispatch origin for this call must be _Signed_ and the sender must have a registered550 * sub identity of `sub`.551 **/552 removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;553 /**554 * Alter the associated name of the given sub-account.555 * 556 * The dispatch origin for this call must be _Signed_ and the sender must have a registered557 * sub identity of `sub`.558 **/559 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]>;560 /**561 * Request a judgement from a registrar.562 * 563 * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement564 * given.565 * 566 * The dispatch origin for this call must be _Signed_ and the sender must have a567 * registered identity.568 * 569 * - `reg_index`: The index of the registrar whose judgement is requested.570 * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:571 * 572 * ```nocompile573 * Self::registrars().get(reg_index).unwrap().fee574 * ```575 * 576 * Emits `JudgementRequested` if successful.577 * 578 * # <weight>579 * - `O(R + X)`.580 * - One balance-reserve operation.581 * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.582 * - One event.583 * # </weight>584 **/585 requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;586 /**587 * Change the account associated with a registrar.588 * 589 * The dispatch origin for this call must be _Signed_ and the sender must be the account590 * of the registrar whose index is `index`.591 * 592 * - `index`: the index of the registrar whose fee is to be set.593 * - `new`: the new account ID.594 * 595 * # <weight>596 * - `O(R)`.597 * - One storage mutation `O(R)`.598 * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)599 * # </weight>600 **/601 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]>;602 /**603 * Set the fee required for a judgement to be requested from a registrar.604 * 605 * The dispatch origin for this call must be _Signed_ and the sender must be the account606 * of the registrar whose index is `index`.607 * 608 * - `index`: the index of the registrar whose fee is to be set.609 * - `fee`: the new fee.610 * 611 * # <weight>612 * - `O(R)`.613 * - One storage mutation `O(R)`.614 * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)615 * # </weight>616 **/617 setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;618 /**619 * Set the field information for a registrar.620 * 621 * The dispatch origin for this call must be _Signed_ and the sender must be the account622 * of the registrar whose index is `index`.623 * 624 * - `index`: the index of the registrar whose fee is to be set.625 * - `fields`: the fields that the registrar concerns themselves with.626 * 627 * # <weight>628 * - `O(R)`.629 * - One storage mutation `O(R)`.630 * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)631 * # </weight>632 **/633 setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;634 /**635 * Set an account's identity information and reserve the appropriate deposit.636 * 637 * If the account already has identity information, the deposit is taken as part payment638 * for the new deposit.639 * 640 * The dispatch origin for this call must be _Signed_.641 * 642 * - `info`: The identity information.643 * 644 * Emits `IdentitySet` if successful.645 * 646 * # <weight>647 * - `O(X + X' + R)`648 * - where `X` additional-field-count (deposit-bounded and code-bounded)649 * - where `R` judgements-count (registrar-count-bounded)650 * - One balance reserve operation.651 * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).652 * - One event.653 * # </weight>654 **/655 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]>;656 /**657 * Set the sub-accounts of the sender.658 * 659 * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned660 * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.661 * 662 * The dispatch origin for this call must be _Signed_ and the sender must have a registered663 * identity.664 * 665 * - `subs`: The identity's (new) sub-accounts.666 * 667 * # <weight>668 * - `O(P + S)`669 * - where `P` old-subs-count (hard- and deposit-bounded).670 * - where `S` subs-count (hard- and deposit-bounded).671 * - At most one balance operations.672 * - DB:673 * - `P + S` storage mutations (codec complexity `O(1)`)674 * - One storage read (codec complexity `O(P)`).675 * - One storage write (codec complexity `O(S)`).676 * - One storage-exists (`IdentityOf::contains_key`).677 * # </weight>678 **/679 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]>>]>;680 /**681 * Generic tx682 **/683 [key: string]: SubmittableExtrinsicFunction<ApiType>;684 };685 inflation: {686 /**687 * This method sets the inflation start date. Can be only called once.688 * Inflation start block can be backdated and will catch up. The method will create Treasury689 * account if it does not exist and perform the first inflation deposit.690 * 691 * # Permissions692 * 693 * * Root694 * 695 * # Arguments696 * 697 * * inflation_start_relay_block: The relay chain block at which inflation should start698 **/699 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;700 /**701 * Generic tx702 **/703 [key: string]: SubmittableExtrinsicFunction<ApiType>;704 };705 maintenance: {706 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;707 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;708 /**709 * Execute a runtime call stored as a preimage.710 * 711 * `weight_bound` is the maximum weight that the caller is willing712 * to allow the extrinsic to be executed with.713 **/714 executePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array, weightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, SpWeightsWeightV2Weight]>;715 /**716 * Generic tx717 **/718 [key: string]: SubmittableExtrinsicFunction<ApiType>;719 };720 parachainInfo: {721 /**722 * Generic tx723 **/724 [key: string]: SubmittableExtrinsicFunction<ApiType>;725 };726 parachainSystem: {727 /**728 * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied729 * later.730 * 731 * The `check_version` parameter sets a boolean flag for whether or not the runtime's spec732 * version and name should be verified on upgrade. Since the authorization only has a hash,733 * it cannot actually perform the verification.734 * 735 * This call requires Root origin.736 **/737 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array, checkVersion: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, bool]>;738 /**739 * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.740 * 741 * If the authorization required a version check, this call will ensure the spec name742 * remains unchanged and that the spec version has increased.743 * 744 * Note that this function will not apply the new `code`, but only attempt to schedule the745 * upgrade with the Relay Chain.746 * 747 * All origins are allowed.748 **/749 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;750 /**751 * Set the current validation data.752 * 753 * This should be invoked exactly once per block. It will panic at the finalization754 * phase if the call was not invoked.755 * 756 * The dispatch origin for this call must be `Inherent`757 * 758 * As a side effect, this function upgrades the current validation function759 * if the appropriate time has come.760 **/761 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;762 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;763 /**764 * Generic tx765 **/766 [key: string]: SubmittableExtrinsicFunction<ApiType>;767 };768 polkadotXcm: {769 /**770 * Execute an XCM message from a local, signed, origin.771 * 772 * An event is deposited indicating whether `msg` could be executed completely or only773 * partially.774 * 775 * No more than `max_weight` will be used in its attempted execution. If this is less than the776 * maximum amount of weight that the message could take to be executed, then no execution777 * attempt will be made.778 * 779 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully780 * to completion; only that *some* of it was executed.781 **/782 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, SpWeightsWeightV2Weight]>;783 /**784 * Set a safe XCM version (the version that XCM should be encoded with if the most recent785 * version a destination can accept is unknown).786 * 787 * - `origin`: Must be an origin specified by AdminOrigin.788 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.789 **/790 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;791 /**792 * Ask a location to notify us regarding their XCM version and any changes to it.793 * 794 * - `origin`: Must be an origin specified by AdminOrigin.795 * - `location`: The location to which we should subscribe for XCM version notifications.796 **/797 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;798 /**799 * Set or unset the global suspension state of the XCM executor.800 * 801 * - `origin`: Must be an origin specified by AdminOrigin.802 * - `suspended`: `true` to suspend, `false` to resume.803 **/804 forceSuspension: AugmentedSubmittable<(suspended: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [bool]>;805 /**806 * Require that a particular destination should no longer notify us regarding any XCM807 * version changes.808 * 809 * - `origin`: Must be an origin specified by AdminOrigin.810 * - `location`: The location to which we are currently subscribed for XCM version811 * notifications which we no longer desire.812 **/813 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;814 /**815 * Extoll that a particular destination can be communicated with through a particular816 * version of XCM.817 * 818 * - `origin`: Must be an origin specified by AdminOrigin.819 * - `location`: The destination that is being described.820 * - `xcm_version`: The latest version of XCM that `location` supports.821 **/822 forceXcmVersion: AugmentedSubmittable<(location: XcmV3MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV3MultiLocation, u32]>;823 /**824 * Transfer some assets from the local chain to the sovereign account of a destination825 * chain and forward a notification XCM.826 * 827 * Fee payment on the destination side is made from the asset in the `assets` vector of828 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight829 * is needed than `weight_limit`, then the operation will fail and the assets send may be830 * at risk.831 * 832 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.833 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send834 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.835 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be836 * an `AccountId32` value.837 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the838 * `dest` side.839 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay840 * fees.841 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.842 **/843 limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV3WeightLimit]>;844 /**845 * Teleport some assets from the local chain to some destination chain.846 * 847 * Fee payment on the destination side is made from the asset in the `assets` vector of848 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight849 * is needed than `weight_limit`, then the operation will fail and the assets send may be850 * at risk.851 * 852 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.853 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send854 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.855 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be856 * an `AccountId32` value.857 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the858 * `dest` side. May not be empty.859 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay860 * fees.861 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.862 **/863 limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV3WeightLimit]>;864 /**865 * Transfer some assets from the local chain to the sovereign account of a destination866 * chain and forward a notification XCM.867 * 868 * Fee payment on the destination side is made from the asset in the `assets` vector of869 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,870 * with all fees taken as needed from the asset.871 * 872 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.873 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send874 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.875 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be876 * an `AccountId32` value.877 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the878 * `dest` side.879 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay880 * fees.881 **/882 reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;883 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;884 /**885 * Teleport some assets from the local chain to some destination chain.886 * 887 * Fee payment on the destination side is made from the asset in the `assets` vector of888 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,889 * with all fees taken as needed from the asset.890 * 891 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.892 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send893 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.894 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be895 * an `AccountId32` value.896 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the897 * `dest` side. May not be empty.898 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay899 * fees.900 **/901 teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;902 /**903 * Generic tx904 **/905 [key: string]: SubmittableExtrinsicFunction<ApiType>;906 };907 preimage: {908 /**909 * Register a preimage on-chain.910 * 911 * If the preimage was previously requested, no fees or deposits are taken for providing912 * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.913 **/914 notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;915 /**916 * Request a preimage be uploaded to the chain without paying any fees or deposits.917 * 918 * If the preimage requests has already been provided on-chain, we unreserve any deposit919 * a user may have paid, and take the control of the preimage out of their hands.920 **/921 requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;922 /**923 * Clear an unrequested preimage from the runtime storage.924 * 925 * If `len` is provided, then it will be a much cheaper operation.926 * 927 * - `hash`: The hash of the preimage to be removed from the store.928 * - `len`: The length of the preimage of `hash`.929 **/930 unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;931 /**932 * Clear a previously made request for a preimage.933 * 934 * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.935 **/936 unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;937 /**938 * Generic tx939 **/940 [key: string]: SubmittableExtrinsicFunction<ApiType>;941 };942 session: {943 /**944 * Removes any session key(s) of the function caller.945 * 946 * This doesn't take effect until the next session.947 * 948 * The dispatch origin of this function must be Signed and the account must be either be949 * convertible to a validator ID using the chain's typical addressing system (this usually950 * means being a controller account) or directly convertible into a validator ID (which951 * usually means being a stash account).952 * 953 * ## Complexity954 * - `O(1)` in number of key types. Actual cost depends on the number of length of955 * `T::Keys::key_ids()` which is fixed.956 **/957 purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;958 /**959 * Sets the session key(s) of the function caller to `keys`.960 * Allows an account to set its session key prior to becoming a validator.961 * This doesn't take effect until the next session.962 * 963 * The dispatch origin of this function must be signed.964 * 965 * ## Complexity966 * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is967 * fixed.968 **/969 setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;970 /**971 * Generic tx972 **/973 [key: string]: SubmittableExtrinsicFunction<ApiType>;974 };975 stateTrieMigration: {976 /**977 * Continue the migration for the given `limits`.978 * 979 * The dispatch origin of this call can be any signed account.980 * 981 * This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,982 * Upon successful execution, the transaction fee is returned.983 * 984 * The (potentially over-estimated) of the byte length of all the data read must be985 * provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing986 * that executing the current `MigrationTask` with the given `limits` will not exceed987 * `real_size_upper` bytes of read data.988 * 989 * The `witness_task` is merely a helper to prevent the caller from being slashed or990 * generally trigger a migration that they do not intend. This parameter is just a message991 * from caller, saying that they believed `witness_task` was the last state of the992 * migration, and they only wish for their transaction to do anything, if this assumption993 * holds. In case `witness_task` does not match, the transaction fails.994 * 995 * Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the996 * recommended way of doing this is to pass a `limit` that only bounds `count`, as the997 * `size` limit can always be overwritten.998 **/999 continueMigrate: AugmentedSubmittable<(limits: PalletStateTrieMigrationMigrationLimits | { size_?: any; item?: any } | string | Uint8Array, realSizeUpper: u32 | AnyNumber | Uint8Array, witnessTask: PalletStateTrieMigrationMigrationTask | { progressTop?: any; progressChild?: any; size_?: any; topItems?: any; childItems?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletStateTrieMigrationMigrationLimits, u32, PalletStateTrieMigrationMigrationTask]>;1000 /**1001 * Control the automatic migration.1002 * 1003 * The dispatch origin of this call must be [`Config::ControlOrigin`].1004 **/1005 controlAutoMigration: AugmentedSubmittable<(maybeConfig: Option<PalletStateTrieMigrationMigrationLimits> | null | Uint8Array | PalletStateTrieMigrationMigrationLimits | { size_?: any; item?: any } | string) => SubmittableExtrinsic<ApiType>, [Option<PalletStateTrieMigrationMigrationLimits>]>;1006 /**1007 * Forcefully set the progress the running migration.1008 * 1009 * This is only useful in one case: the next key to migrate is too big to be migrated with1010 * a signed account, in a parachain context, and we simply want to skip it. A reasonable1011 * example of this would be `:code:`, which is both very expensive to migrate, and commonly1012 * used, so probably it is already migrated.1013 * 1014 * In case you mess things up, you can also, in principle, use this to reset the migration1015 * process.1016 **/1017 forceSetProgress: AugmentedSubmittable<(progressTop: PalletStateTrieMigrationProgress | { ToStart: any } | { LastKey: any } | { Complete: any } | string | Uint8Array, progressChild: PalletStateTrieMigrationProgress | { ToStart: any } | { LastKey: any } | { Complete: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletStateTrieMigrationProgress, PalletStateTrieMigrationProgress]>;1018 /**1019 * Migrate the list of child keys by iterating each of them one by one.1020 * 1021 * All of the given child keys must be present under one `child_root`.1022 * 1023 * This does not affect the global migration process tracker ([`MigrationProcess`]), and1024 * should only be used in case any keys are leftover due to a bug.1025 **/1026 migrateCustomChild: AugmentedSubmittable<(root: Bytes | string | Uint8Array, childKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[], totalSize: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Vec<Bytes>, u32]>;1027 /**1028 * Migrate the list of top keys by iterating each of them one by one.1029 * 1030 * This does not affect the global migration process tracker ([`MigrationProcess`]), and1031 * should only be used in case any keys are leftover due to a bug.1032 **/1033 migrateCustomTop: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[], witnessSize: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>, u32]>;1034 /**1035 * Set the maximum limit of the signed migration.1036 **/1037 setSignedMaxLimits: AugmentedSubmittable<(limits: PalletStateTrieMigrationMigrationLimits | { size_?: any; item?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletStateTrieMigrationMigrationLimits]>;1038 /**1039 * Generic tx1040 **/1041 [key: string]: SubmittableExtrinsicFunction<ApiType>;1042 };1043 structure: {1044 /**1045 * Generic tx1046 **/1047 [key: string]: SubmittableExtrinsicFunction<ApiType>;1048 };1049 sudo: {1050 /**1051 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo1052 * key.1053 * 1054 * The dispatch origin for this call must be _Signed_.1055 * 1056 * ## Complexity1057 * - O(1).1058 **/1059 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1060 /**1061 * Authenticates the sudo key and dispatches a function call with `Root` origin.1062 * 1063 * The dispatch origin for this call must be _Signed_.1064 * 1065 * ## Complexity1066 * - O(1).1067 **/1068 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;1069 /**1070 * Authenticates the sudo key and dispatches a function call with `Signed` origin from1071 * a given account.1072 * 1073 * The dispatch origin for this call must be _Signed_.1074 * 1075 * ## Complexity1076 * - O(1).1077 **/1078 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]>;1079 /**1080 * Authenticates the sudo key and dispatches a function call with `Root` origin.1081 * This function does not check the weight of the call, and instead allows the1082 * Sudo user to specify the weight of the call.1083 * 1084 * The dispatch origin for this call must be _Signed_.1085 * 1086 * ## Complexity1087 * - O(1).1088 **/1089 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;1090 /**1091 * Generic tx1092 **/1093 [key: string]: SubmittableExtrinsicFunction<ApiType>;1094 };1095 system: {1096 /**1097 * Kill all storage items with a key that starts with the given prefix.1098 * 1099 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1100 * the prefix we are removing to accurately calculate the weight of this function.1101 **/1102 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1103 /**1104 * Kill some items from storage.1105 **/1106 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1107 /**1108 * Make some on-chain remark.1109 * 1110 * - `O(1)`1111 **/1112 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1113 /**1114 * Make some on-chain remark and emit event.1115 **/1116 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1117 /**1118 * Set the new runtime code.1119 **/1120 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1121 /**1122 * Set the new runtime code without doing any checks of the given `code`.1123 **/1124 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1125 /**1126 * Set the number of pages in the WebAssembly environment's heap.1127 **/1128 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1129 /**1130 * Set some items of storage.1131 **/1132 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1133 /**1134 * Generic tx1135 **/1136 [key: string]: SubmittableExtrinsicFunction<ApiType>;1137 };1138 testUtils: {1139 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1140 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1141 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1142 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1143 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1144 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1145 /**1146 * Generic tx1147 **/1148 [key: string]: SubmittableExtrinsicFunction<ApiType>;1149 };1150 timestamp: {1151 /**1152 * Set the current time.1153 * 1154 * This call should be invoked exactly once per block. It will panic at the finalization1155 * phase, if this call hasn't been invoked by that time.1156 * 1157 * The timestamp should be greater than the previous one by the amount specified by1158 * `MinimumPeriod`.1159 * 1160 * The dispatch origin for this call must be `Inherent`.1161 * 1162 * ## Complexity1163 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1164 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1165 * `on_finalize`)1166 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1167 **/1168 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1169 /**1170 * Generic tx1171 **/1172 [key: string]: SubmittableExtrinsicFunction<ApiType>;1173 };1174 tokens: {1175 /**1176 * Exactly as `transfer`, except the origin must be root and the source1177 * account may be specified.1178 * 1179 * The dispatch origin for this call must be _Root_.1180 * 1181 * - `source`: The sender of the transfer.1182 * - `dest`: The recipient of the transfer.1183 * - `currency_id`: currency type.1184 * - `amount`: free balance amount to tranfer.1185 **/1186 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>]>;1187 /**1188 * Set the balances of a given account.1189 * 1190 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1191 * will also decrease the total issuance of the system1192 * (`TotalIssuance`). If the new free or reserved balance is below the1193 * existential deposit, it will reap the `AccountInfo`.1194 * 1195 * The dispatch origin for this call is `root`.1196 **/1197 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>]>;1198 /**1199 * Transfer some liquid free balance to another account.1200 * 1201 * `transfer` will set the `FreeBalance` of the sender and receiver.1202 * It will decrease the total issuance of the system by the1203 * `TransferFee`. If the sender's account is below the existential1204 * deposit as a result of the transfer, the account will be reaped.1205 * 1206 * The dispatch origin for this call must be `Signed` by the1207 * transactor.1208 * 1209 * - `dest`: The recipient of the transfer.1210 * - `currency_id`: currency type.1211 * - `amount`: free balance amount to tranfer.1212 **/1213 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>]>;1214 /**1215 * Transfer all remaining balance to the given account.1216 * 1217 * NOTE: This function only attempts to transfer _transferable_1218 * balances. This means that any locked, reserved, or existential1219 * deposits (when `keep_alive` is `true`), will not be transferred by1220 * this function. To ensure that this function results in a killed1221 * account, you might need to prepare the account by removing any1222 * reference counters, storage deposits, etc...1223 * 1224 * The dispatch origin for this call must be `Signed` by the1225 * transactor.1226 * 1227 * - `dest`: The recipient of the transfer.1228 * - `currency_id`: currency type.1229 * - `keep_alive`: A boolean to determine if the `transfer_all`1230 * operation should send all of the funds the account has, causing1231 * the sender account to be killed (false), or transfer everything1232 * except at least the existential deposit, which will guarantee to1233 * keep the sender account alive (true).1234 **/1235 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]>;1236 /**1237 * Same as the [`transfer`] call, but with a check that the transfer1238 * will not kill the origin account.1239 * 1240 * 99% of the time you want [`transfer`] instead.1241 * 1242 * The dispatch origin for this call must be `Signed` by the1243 * transactor.1244 * 1245 * - `dest`: The recipient of the transfer.1246 * - `currency_id`: currency type.1247 * - `amount`: free balance amount to tranfer.1248 **/1249 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>]>;1250 /**1251 * Generic tx1252 **/1253 [key: string]: SubmittableExtrinsicFunction<ApiType>;1254 };1255 treasury: {1256 /**1257 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1258 * and the original deposit will be returned.1259 * 1260 * May only be called from `T::ApproveOrigin`.1261 * 1262 * ## Complexity1263 * - O(1).1264 **/1265 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1266 /**1267 * Put forward a suggestion for spending. A deposit proportional to the value1268 * is reserved and slashed if the proposal is rejected. It is returned once the1269 * proposal is awarded.1270 * 1271 * ## Complexity1272 * - O(1)1273 **/1274 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]>;1275 /**1276 * Reject a proposed spend. The original deposit will be slashed.1277 * 1278 * May only be called from `T::RejectOrigin`.1279 * 1280 * ## Complexity1281 * - O(1)1282 **/1283 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1284 /**1285 * Force a previously approved proposal to be removed from the approval queue.1286 * The original deposit will no longer be returned.1287 * 1288 * May only be called from `T::RejectOrigin`.1289 * - `proposal_id`: The index of a proposal1290 * 1291 * ## Complexity1292 * - O(A) where `A` is the number of approvals1293 * 1294 * Errors:1295 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1296 * i.e., the proposal has not been approved. This could also mean the proposal does not1297 * exist altogether, thus there is no way it would have been approved in the first place.1298 **/1299 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1300 /**1301 * Propose and approve a spend of treasury funds.1302 * 1303 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1304 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1305 * - `beneficiary`: The destination account for the transfer.1306 * 1307 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1308 * beneficiary.1309 **/1310 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]>;1311 /**1312 * Generic tx1313 **/1314 [key: string]: SubmittableExtrinsicFunction<ApiType>;1315 };1316 unique: {1317 /**1318 * Add an admin to a collection.1319 * 1320 * NFT Collection can be controlled by multiple admin addresses1321 * (some which can also be servers, for example). Admins can issue1322 * and burn NFTs, as well as add and remove other admins,1323 * but cannot change NFT or Collection ownership.1324 * 1325 * # Permissions1326 * 1327 * * Collection owner1328 * * Collection admin1329 * 1330 * # Arguments1331 * 1332 * * `collection_id`: ID of the Collection to add an admin for.1333 * * `new_admin`: Address of new admin to add.1334 **/1335 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1336 /**1337 * Add an address to allow list.1338 * 1339 * # Permissions1340 * 1341 * * Collection owner1342 * * Collection admin1343 * 1344 * # Arguments1345 * 1346 * * `collection_id`: ID of the modified collection.1347 * * `address`: ID of the address to be added to the allowlist.1348 **/1349 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1350 /**1351 * Allow a non-permissioned address to transfer or burn an item.1352 * 1353 * # Permissions1354 * 1355 * * Collection owner1356 * * Collection admin1357 * * Current item owner1358 * 1359 * # Arguments1360 * 1361 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1362 * * `collection_id`: ID of the collection the item belongs to.1363 * * `item_id`: ID of the item transactions on which are now approved.1364 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1365 * Set to 0 to revoke the approval.1366 **/1367 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]>;1368 /**1369 * Allow a non-permissioned address to transfer or burn an item from owner's eth mirror.1370 * 1371 * # Permissions1372 * 1373 * * Collection owner1374 * * Collection admin1375 * * Current item owner1376 * 1377 * # Arguments1378 * 1379 * * `from`: Owner's account eth mirror1380 * * `to`: Account to be approved to make specific transactions on non-owned tokens.1381 * * `collection_id`: ID of the collection the item belongs to.1382 * * `item_id`: ID of the item transactions on which are now approved.1383 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1384 * Set to 0 to revoke the approval.1385 **/1386 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]>;1387 /**1388 * Destroy a token on behalf of the owner as a non-owner account.1389 * 1390 * See also: [`approve`][`Pallet::approve`].1391 * 1392 * After this method executes, one approval is removed from the total so that1393 * the approved address will not be able to transfer this item again from this owner.1394 * 1395 * # Permissions1396 * 1397 * * Collection owner1398 * * Collection admin1399 * * Current token owner1400 * * Address approved by current item owner1401 * 1402 * # Arguments1403 * 1404 * * `from`: The owner of the burning item.1405 * * `collection_id`: ID of the collection to which the item belongs.1406 * * `item_id`: ID of item to burn.1407 * * `value`: Number of pieces to burn.1408 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1409 * * Fungible Mode: The desired number of pieces to burn.1410 * * Re-Fungible Mode: The desired number of pieces to burn.1411 **/1412 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]>;1413 /**1414 * Destroy an item.1415 * 1416 * # Permissions1417 * 1418 * * Collection owner1419 * * Collection admin1420 * * Current item owner1421 * 1422 * # Arguments1423 * 1424 * * `collection_id`: ID of the collection to which the item belongs.1425 * * `item_id`: ID of item to burn.1426 * * `value`: Number of pieces of the item to destroy.1427 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1428 * * Fungible Mode: The desired number of pieces to burn.1429 * * Re-Fungible Mode: The desired number of pieces to burn.1430 **/1431 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1432 /**1433 * Change the owner of the collection.1434 * 1435 * # Permissions1436 * 1437 * * Collection owner1438 * 1439 * # Arguments1440 * 1441 * * `collection_id`: ID of the modified collection.1442 * * `new_owner`: ID of the account that will become the owner.1443 **/1444 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1445 /**1446 * Confirm own sponsorship of a collection, becoming the sponsor.1447 * 1448 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1449 * Sponsor can pay the fees of a transaction instead of the sender,1450 * but only within specified limits.1451 * 1452 * # Permissions1453 * 1454 * * Sponsor-to-be1455 * 1456 * # Arguments1457 * 1458 * * `collection_id`: ID of the collection with the pending sponsor.1459 **/1460 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1461 /**1462 * Create a collection of tokens.1463 * 1464 * Each Token may have multiple properties encoded as an array of bytes1465 * of certain length. The initial owner of the collection is set1466 * to the address that signed the transaction and can be changed later.1467 * 1468 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1469 * 1470 * # Permissions1471 * 1472 * * Anyone - becomes the owner of the new collection.1473 * 1474 * # Arguments1475 * 1476 * * `collection_name`: Wide-character string with collection name1477 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1478 * * `collection_description`: Wide-character string with collection description1479 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1480 * * `token_prefix`: Byte string containing the token prefix to mark a collection1481 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1482 * * `mode`: Type of items stored in the collection and type dependent data.1483 * 1484 * returns collection ID1485 * 1486 * Deprecated: `create_collection_ex` is more up-to-date and advanced, prefer it instead.1487 **/1488 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]>;1489 /**1490 * Create a collection with explicit parameters.1491 * 1492 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1493 * 1494 * # Permissions1495 * 1496 * * Anyone - becomes the owner of the new collection.1497 * 1498 * # Arguments1499 * 1500 * * `data`: Explicit data of a collection used for its creation.1501 **/1502 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]>;1503 /**1504 * Mint an item within a collection.1505 * 1506 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1507 * 1508 * # Permissions1509 * 1510 * * Collection owner1511 * * Collection admin1512 * * Anyone if1513 * * Allow List is enabled, and1514 * * Address is added to allow list, and1515 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1516 * 1517 * # Arguments1518 * 1519 * * `collection_id`: ID of the collection to which an item would belong.1520 * * `owner`: Address of the initial owner of the item.1521 * * `data`: Token data describing the item to store on chain.1522 **/1523 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]>;1524 /**1525 * Create multiple items within a collection.1526 * 1527 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1528 * 1529 * # Permissions1530 * 1531 * * Collection owner1532 * * Collection admin1533 * * Anyone if1534 * * Allow List is enabled, and1535 * * Address is added to the allow list, and1536 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1537 * 1538 * # Arguments1539 * 1540 * * `collection_id`: ID of the collection to which the tokens would belong.1541 * * `owner`: Address of the initial owner of the tokens.1542 * * `items_data`: Vector of data describing each item to be created.1543 **/1544 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>]>;1545 /**1546 * Create multiple items within a collection with explicitly specified initial parameters.1547 * 1548 * # Permissions1549 * 1550 * * Collection owner1551 * * Collection admin1552 * * Anyone if1553 * * Allow List is enabled, and1554 * * Address is added to allow list, and1555 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1556 * 1557 * # Arguments1558 * 1559 * * `collection_id`: ID of the collection to which the tokens would belong.1560 * * `data`: Explicit item creation data.1561 **/1562 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1563 /**1564 * Delete specified collection properties.1565 * 1566 * # Permissions1567 * 1568 * * Collection Owner1569 * * Collection Admin1570 * 1571 * # Arguments1572 * 1573 * * `collection_id`: ID of the modified collection.1574 * * `property_keys`: Vector of keys of the properties to be deleted.1575 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1576 **/1577 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1578 /**1579 * Delete specified token properties. Currently properties only work with NFTs.1580 * 1581 * # Permissions1582 * 1583 * * Depends on collection's token property permissions and specified property mutability:1584 * * Collection owner1585 * * Collection admin1586 * * Token owner1587 * 1588 * # Arguments1589 * 1590 * * `collection_id`: ID of the collection to which the token belongs.1591 * * `token_id`: ID of the modified token.1592 * * `property_keys`: Vector of keys of the properties to be deleted.1593 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1594 **/1595 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1596 /**1597 * Destroy a collection if no tokens exist within.1598 * 1599 * # Permissions1600 * 1601 * * Collection owner1602 * 1603 * # Arguments1604 * 1605 * * `collection_id`: Collection to destroy.1606 **/1607 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1608 /**1609 * Repairs a collection if the data was somehow corrupted.1610 * 1611 * # Arguments1612 * 1613 * * `collection_id`: ID of the collection to repair.1614 **/1615 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1616 /**1617 * Repairs a token if the data was somehow corrupted.1618 * 1619 * # Arguments1620 * 1621 * * `collection_id`: ID of the collection the item belongs to.1622 * * `item_id`: ID of the item.1623 **/1624 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1625 /**1626 * Remove admin of a collection.1627 * 1628 * An admin address can remove itself. List of admins may become empty,1629 * in which case only Collection Owner will be able to add an Admin.1630 * 1631 * # Permissions1632 * 1633 * * Collection owner1634 * * Collection admin1635 * 1636 * # Arguments1637 * 1638 * * `collection_id`: ID of the collection to remove the admin for.1639 * * `account_id`: Address of the admin to remove.1640 **/1641 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1642 /**1643 * Remove a collection's a sponsor, making everyone pay for their own transactions.1644 * 1645 * # Permissions1646 * 1647 * * Collection owner1648 * 1649 * # Arguments1650 * 1651 * * `collection_id`: ID of the collection with the sponsor to remove.1652 **/1653 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1654 /**1655 * Remove an address from allow list.1656 * 1657 * # Permissions1658 * 1659 * * Collection owner1660 * * Collection admin1661 * 1662 * # Arguments1663 * 1664 * * `collection_id`: ID of the modified collection.1665 * * `address`: ID of the address to be removed from the allowlist.1666 **/1667 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1668 /**1669 * Re-partition a refungible token, while owning all of its parts/pieces.1670 * 1671 * # Permissions1672 * 1673 * * Token owner (must own every part)1674 * 1675 * # Arguments1676 * 1677 * * `collection_id`: ID of the collection the RFT belongs to.1678 * * `token_id`: ID of the RFT.1679 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1680 **/1681 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1682 /**1683 * Sets or unsets the approval of a given operator.1684 * 1685 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1686 * 1687 * # Arguments1688 * 1689 * * `owner`: Token owner1690 * * `operator`: Operator1691 * * `approve`: Should operator status be granted or revoked?1692 **/1693 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1694 /**1695 * Set specific limits of a collection. Empty, or None fields mean chain default.1696 * 1697 * # Permissions1698 * 1699 * * Collection owner1700 * * Collection admin1701 * 1702 * # Arguments1703 * 1704 * * `collection_id`: ID of the modified collection.1705 * * `new_limit`: New limits of the collection. Fields that are not set (None)1706 * will not overwrite the old ones.1707 **/1708 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]>;1709 /**1710 * Set specific permissions of a collection. Empty, or None fields mean chain default.1711 * 1712 * # Permissions1713 * 1714 * * Collection owner1715 * * Collection admin1716 * 1717 * # Arguments1718 * 1719 * * `collection_id`: ID of the modified collection.1720 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1721 * will not overwrite the old ones.1722 **/1723 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1724 /**1725 * Add or change collection properties.1726 * 1727 * # Permissions1728 * 1729 * * Collection owner1730 * * Collection admin1731 * 1732 * # Arguments1733 * 1734 * * `collection_id`: ID of the modified collection.1735 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1736 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1737 **/1738 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1739 /**1740 * Set (invite) a new collection sponsor.1741 * 1742 * If successful, confirmation from the sponsor-to-be will be pending.1743 * 1744 * # Permissions1745 * 1746 * * Collection owner1747 * * Collection admin1748 * 1749 * # Arguments1750 * 1751 * * `collection_id`: ID of the modified collection.1752 * * `new_sponsor`: ID of the account of the sponsor-to-be.1753 **/1754 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1755 /**1756 * Add or change token properties according to collection's permissions.1757 * Currently properties only work with NFTs.1758 * 1759 * # Permissions1760 * 1761 * * Depends on collection's token property permissions and specified property mutability:1762 * * Collection owner1763 * * Collection admin1764 * * Token owner1765 * 1766 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1767 * 1768 * # Arguments1769 * 1770 * * `collection_id: ID of the collection to which the token belongs.1771 * * `token_id`: ID of the modified token.1772 * * `properties`: Vector of key-value pairs stored as the token's metadata.1773 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1774 **/1775 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>]>;1776 /**1777 * Add or change token property permissions of a collection.1778 * 1779 * Without a permission for a particular key, a property with that key1780 * cannot be created in a token.1781 * 1782 * # Permissions1783 * 1784 * * Collection owner1785 * * Collection admin1786 * 1787 * # Arguments1788 * 1789 * * `collection_id`: ID of the modified collection.1790 * * `property_permissions`: Vector of permissions for property keys.1791 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1792 **/1793 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1794 /**1795 * Completely allow or disallow transfers for a particular collection.1796 * 1797 * # Permissions1798 * 1799 * * Collection owner1800 * 1801 * # Arguments1802 * 1803 * * `collection_id`: ID of the collection.1804 * * `value`: New value of the flag, are transfers allowed?1805 **/1806 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1807 /**1808 * Change ownership of the token.1809 * 1810 * # Permissions1811 * 1812 * * Collection owner1813 * * Collection admin1814 * * Current token owner1815 * 1816 * # Arguments1817 * 1818 * * `recipient`: Address of token recipient.1819 * * `collection_id`: ID of the collection the item belongs to.1820 * * `item_id`: ID of the item.1821 * * Non-Fungible Mode: Required.1822 * * Fungible Mode: Ignored.1823 * * Re-Fungible Mode: Required.1824 * 1825 * * `value`: Amount to transfer.1826 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1827 * * Fungible Mode: The desired number of pieces to transfer.1828 * * Re-Fungible Mode: The desired number of pieces to transfer.1829 **/1830 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]>;1831 /**1832 * Change ownership of an item on behalf of the owner as a non-owner account.1833 * 1834 * See the [`approve`][`Pallet::approve`] method for additional information.1835 * 1836 * After this method executes, one approval is removed from the total so that1837 * the approved address will not be able to transfer this item again from this owner.1838 * 1839 * # Permissions1840 * 1841 * * Collection owner1842 * * Collection admin1843 * * Current item owner1844 * * Address approved by current item owner1845 * 1846 * # Arguments1847 * 1848 * * `from`: Address that currently owns the token.1849 * * `recipient`: Address of the new token-owner-to-be.1850 * * `collection_id`: ID of the collection the item.1851 * * `item_id`: ID of the item to be transferred.1852 * * `value`: Amount to transfer.1853 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1854 * * Fungible Mode: The desired number of pieces to transfer.1855 * * Re-Fungible Mode: The desired number of pieces to transfer.1856 **/1857 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]>;1858 /**1859 * Generic tx1860 **/1861 [key: string]: SubmittableExtrinsicFunction<ApiType>;1862 };1863 vesting: {1864 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1865 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1866 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>]>;1867 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]>;1868 /**1869 * Generic tx1870 **/1871 [key: string]: SubmittableExtrinsicFunction<ApiType>;1872 };1873 xcmpQueue: {1874 /**1875 * Resumes all XCM executions for the XCMP queue.1876 * 1877 * Note that this function doesn't change the status of the in/out bound channels.1878 * 1879 * - `origin`: Must pass `ControllerOrigin`.1880 **/1881 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1882 /**1883 * Services a single overweight XCM.1884 * 1885 * - `origin`: Must pass `ExecuteOverweightOrigin`.1886 * - `index`: The index of the overweight XCM to service1887 * - `weight_limit`: The amount of weight that XCM execution may take.1888 * 1889 * Errors:1890 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1891 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1892 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1893 * 1894 * Events:1895 * - `OverweightServiced`: On success.1896 **/1897 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;1898 /**1899 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1900 * 1901 * - `origin`: Must pass `ControllerOrigin`.1902 **/1903 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1904 /**1905 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1906 * messages from the channel.1907 * 1908 * - `origin`: Must pass `Root`.1909 * - `new`: Desired value for `QueueConfigData.drop_threshold`1910 **/1911 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1912 /**1913 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1914 * message sending may recommence after it has been suspended.1915 * 1916 * - `origin`: Must pass `Root`.1917 * - `new`: Desired value for `QueueConfigData.resume_threshold`1918 **/1919 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1920 /**1921 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1922 * suspend their sending.1923 * 1924 * - `origin`: Must pass `Root`.1925 * - `new`: Desired value for `QueueConfigData.suspend_value`1926 **/1927 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1928 /**1929 * Overwrites the amount of remaining weight under which we stop processing messages.1930 * 1931 * - `origin`: Must pass `Root`.1932 * - `new`: Desired value for `QueueConfigData.threshold_weight`1933 **/1934 updateThresholdWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1935 /**1936 * Overwrites the speed to which the available weight approaches the maximum weight.1937 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1938 * 1939 * - `origin`: Must pass `Root`.1940 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1941 **/1942 updateWeightRestrictDecay: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1943 /**1944 * Overwrite the maximum amount of weight any individual message may consume.1945 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1946 * 1947 * - `origin`: Must pass `Root`.1948 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1949 **/1950 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;1951 /**1952 * Generic tx1953 **/1954 [key: string]: SubmittableExtrinsicFunction<ApiType>;1955 };1956 xTokens: {1957 /**1958 * Transfer native currencies.1959 * 1960 * `dest_weight_limit` is the weight for XCM execution on the dest1961 * chain, and it would be charged from the transferred assets. If set1962 * below requirements, the execution may fail and assets wouldn't be1963 * received.1964 * 1965 * It's a no-op if any error on local XCM execution or message sending.1966 * Note sending assets out per se doesn't guarantee they would be1967 * received. Receiving depends on if the XCM message could be delivered1968 * by the network, and if the receiving chain would handle1969 * messages correctly.1970 **/1971 transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1972 /**1973 * Transfer `MultiAsset`.1974 * 1975 * `dest_weight_limit` is the weight for XCM execution on the dest1976 * chain, and it would be charged from the transferred assets. If set1977 * below requirements, the execution may fail and assets wouldn't be1978 * received.1979 * 1980 * It's a no-op if any error on local XCM execution or message sending.1981 * Note sending assets out per se doesn't guarantee they would be1982 * received. Receiving depends on if the XCM message could be delivered1983 * by the network, and if the receiving chain would handle1984 * messages correctly.1985 **/1986 transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V2: any } | { V3: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV3WeightLimit]>;1987 /**1988 * Transfer several `MultiAsset` specifying the item to be used as fee1989 * 1990 * `dest_weight_limit` is the weight for XCM execution on the dest1991 * chain, and it would be charged from the transferred assets. If set1992 * below requirements, the execution may fail and assets wouldn't be1993 * received.1994 * 1995 * `fee_item` is index of the MultiAssets that we want to use for1996 * payment1997 * 1998 * It's a no-op if any error on local XCM execution or message sending.1999 * Note sending assets out per se doesn't guarantee they would be2000 * received. Receiving depends on if the XCM message could be delivered2001 * by the network, and if the receiving chain would handle2002 * messages correctly.2003 **/2004 transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V2: any } | { V3: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, XcmV3WeightLimit]>;2005 /**2006 * Transfer `MultiAsset` specifying the fee and amount as separate.2007 * 2008 * `dest_weight_limit` is the weight for XCM execution on the dest2009 * chain, and it would be charged from the transferred assets. If set2010 * below requirements, the execution may fail and assets wouldn't be2011 * received.2012 * 2013 * `fee` is the multiasset to be spent to pay for execution in2014 * destination chain. Both fee and amount will be subtracted form the2015 * callers balance For now we only accept fee and asset having the same2016 * `MultiLocation` id.2017 * 2018 * If `fee` is not high enough to cover for the execution costs in the2019 * destination chain, then the assets will be trapped in the2020 * destination chain2021 * 2022 * It's a no-op if any error on local XCM execution or message sending.2023 * Note sending assets out per se doesn't guarantee they would be2024 * received. Receiving depends on if the XCM message could be delivered2025 * by the network, and if the receiving chain would handle2026 * messages correctly.2027 **/2028 transferMultiassetWithFee: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V2: any } | { V3: any } | string | Uint8Array, fee: XcmVersionedMultiAsset | { V2: any } | { V3: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV3WeightLimit]>;2029 /**2030 * Transfer several currencies specifying the item to be used as fee2031 * 2032 * `dest_weight_limit` is the weight for XCM execution on the dest2033 * chain, and it would be charged from the transferred assets. If set2034 * below requirements, the execution may fail and assets wouldn't be2035 * received.2036 * 2037 * `fee_item` is index of the currencies tuple that we want to use for2038 * payment2039 * 2040 * It's a no-op if any error on local XCM execution or message sending.2041 * Note sending assets out per se doesn't guarantee they would be2042 * received. Receiving depends on if the XCM message could be delivered2043 * by the network, and if the receiving chain would handle2044 * messages correctly.2045 **/2046 transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>> | ([PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, XcmV3WeightLimit]>;2047 /**2048 * Transfer native currencies specifying the fee and amount as2049 * separate.2050 * 2051 * `dest_weight_limit` is the weight for XCM execution on the dest2052 * chain, and it would be charged from the transferred assets. If set2053 * below requirements, the execution may fail and assets wouldn't be2054 * received.2055 * 2056 * `fee` is the amount to be spent to pay for execution in destination2057 * chain. Both fee and amount will be subtracted form the callers2058 * balance.2059 * 2060 * If `fee` is not high enough to cover for the execution costs in the2061 * destination chain, then the assets will be trapped in the2062 * destination chain2063 * 2064 * It's a no-op if any error on local XCM execution or message sending.2065 * Note sending assets out per se doesn't guarantee they would be2066 * received. Receiving depends on if the XCM message could be delivered2067 * by the network, and if the receiving chain would handle2068 * messages correctly.2069 **/2070 transferWithFee: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, destWeightLimit: XcmV3WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, XcmV3WeightLimit]>;2071 /**2072 * Generic tx2073 **/2074 [key: string]: SubmittableExtrinsicFunction<ApiType>;2075 };2076 } // AugmentedSubmittables2077} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts113.4 KiBsourcehistory