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, U8aFixed, 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, FrameSupportPreimagesBounded, FrameSupportScheduleDispatchTime, OpalRuntimeOriginCaller, OpalRuntimeRuntimeCommonSessionKeys, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletDemocracyConviction, PalletDemocracyMetadataOwner, PalletDemocracyVoteAccountVote, 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 council: {293 /**294 * Close a vote that is either approved, disapproved or whose voting period has ended.295 * 296 * May be called by any signed account in order to finish voting and close the proposal.297 * 298 * If called before the end of the voting period it will only close the vote if it is299 * has enough votes to be approved or disapproved.300 * 301 * If called after the end of the voting period abstentions are counted as rejections302 * unless there is a prime member set and the prime member cast an approval.303 * 304 * If the close operation completes successfully with disapproval, the transaction fee will305 * be waived. Otherwise execution of the approved operation will be charged to the caller.306 * 307 * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed308 * proposal.309 * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via310 * `storage::read` so it is `size_of::<u32>() == 4` larger than the pure length.311 * 312 * ## Complexity313 * - `O(B + M + P1 + P2)` where:314 * - `B` is `proposal` size in bytes (length-fee-bounded)315 * - `M` is members-count (code- and governance-bounded)316 * - `P1` is the complexity of `proposal` preimage.317 * - `P2` is proposal-count (code-bounded)318 **/319 close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, proposalWeightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, SpWeightsWeightV2Weight, Compact<u32>]>;320 /**321 * Disapprove a proposal, close, and remove it from the system, regardless of its current322 * state.323 * 324 * Must be called by the Root origin.325 * 326 * Parameters:327 * * `proposal_hash`: The hash of the proposal that should be disapproved.328 * 329 * ## Complexity330 * O(P) where P is the number of max proposals331 **/332 disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;333 /**334 * Dispatch a proposal from a member using the `Member` origin.335 * 336 * Origin must be a member of the collective.337 * 338 * ## Complexity:339 * - `O(B + M + P)` where:340 * - `B` is `proposal` size in bytes (length-fee-bounded)341 * - `M` members-count (code-bounded)342 * - `P` complexity of dispatching `proposal`343 **/344 execute: AugmentedSubmittable<(proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Compact<u32>]>;345 /**346 * Add a new proposal to either be voted on or executed directly.347 * 348 * Requires the sender to be member.349 * 350 * `threshold` determines whether `proposal` is executed directly (`threshold < 2`)351 * or put up for voting.352 * 353 * ## Complexity354 * - `O(B + M + P1)` or `O(B + M + P2)` where:355 * - `B` is `proposal` size in bytes (length-fee-bounded)356 * - `M` is members-count (code- and governance-bounded)357 * - branching is influenced by `threshold` where:358 * - `P1` is proposal execution complexity (`threshold < 2`)359 * - `P2` is proposals-count (code-bounded) (`threshold >= 2`)360 **/361 propose: AugmentedSubmittable<(threshold: Compact<u32> | AnyNumber | Uint8Array, proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Call, Compact<u32>]>;362 /**363 * Set the collective's membership.364 * 365 * - `new_members`: The new member list. Be nice to the chain and provide it sorted.366 * - `prime`: The prime member whose vote sets the default.367 * - `old_count`: The upper bound for the previous number of members in storage. Used for368 * weight estimation.369 * 370 * The dispatch of this call must be `SetMembersOrigin`.371 * 372 * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but373 * the weight estimations rely on it to estimate dispatchable weight.374 * 375 * # WARNING:376 * 377 * The `pallet-collective` can also be managed by logic outside of the pallet through the378 * implementation of the trait [`ChangeMembers`].379 * Any call to `set_members` must be careful that the member set doesn't get out of sync380 * with other logic managing the member set.381 * 382 * ## Complexity:383 * - `O(MP + N)` where:384 * - `M` old-members-count (code- and governance-bounded)385 * - `N` new-members-count (code- and governance-bounded)386 * - `P` proposals-count (code-bounded)387 **/388 setMembers: AugmentedSubmittable<(newMembers: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], prime: Option<AccountId32> | null | Uint8Array | AccountId32 | string, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>, Option<AccountId32>, u32]>;389 /**390 * Add an aye or nay vote for the sender to the given proposal.391 * 392 * Requires the sender to be a member.393 * 394 * Transaction fees will be waived if the member is voting on any particular proposal395 * for the first time and the call is successful. Subsequent vote changes will charge a396 * fee.397 * ## Complexity398 * - `O(M)` where `M` is members-count (code- and governance-bounded)399 **/400 vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, bool]>;401 /**402 * Generic tx403 **/404 [key: string]: SubmittableExtrinsicFunction<ApiType>;405 };406 councilMembership: {407 /**408 * Add a member `who` to the set.409 * 410 * May only be called from `T::AddOrigin`.411 **/412 addMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;413 /**414 * Swap out the sending member for some other key `new`.415 * 416 * May only be called from `Signed` origin of a current member.417 * 418 * Prime membership is passed from the origin account to `new`, if extant.419 **/420 changeKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;421 /**422 * Remove the prime member if it exists.423 * 424 * May only be called from `T::PrimeOrigin`.425 **/426 clearPrime: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;427 /**428 * Remove a member `who` from the set.429 * 430 * May only be called from `T::RemoveOrigin`.431 **/432 removeMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;433 /**434 * Change the membership to a new set, disregarding the existing membership. Be nice and435 * pass `members` pre-sorted.436 * 437 * May only be called from `T::ResetOrigin`.438 **/439 resetMembers: AugmentedSubmittable<(members: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;440 /**441 * Set the prime member. Must be a current member.442 * 443 * May only be called from `T::PrimeOrigin`.444 **/445 setPrime: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;446 /**447 * Swap out one member `remove` for another `add`.448 * 449 * May only be called from `T::SwapOrigin`.450 * 451 * Prime membership is *not* passed from `remove` to `add`, if extant.452 **/453 swapMember: AugmentedSubmittable<(remove: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, add: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress]>;454 /**455 * Generic tx456 **/457 [key: string]: SubmittableExtrinsicFunction<ApiType>;458 };459 cumulusXcm: {460 /**461 * Generic tx462 **/463 [key: string]: SubmittableExtrinsicFunction<ApiType>;464 };465 democracy: {466 /**467 * Permanently place a proposal into the blacklist. This prevents it from ever being468 * proposed again.469 * 470 * If called on a queued public or external proposal, then this will result in it being471 * removed. If the `ref_index` supplied is an active referendum with the proposal hash,472 * then it will be cancelled.473 * 474 * The dispatch origin of this call must be `BlacklistOrigin`.475 * 476 * - `proposal_hash`: The proposal hash to blacklist permanently.477 * - `ref_index`: An ongoing referendum whose hash is `proposal_hash`, which will be478 * cancelled.479 * 480 * Weight: `O(p)` (though as this is an high-privilege dispatch, we assume it has a481 * reasonable value).482 **/483 blacklist: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, maybeRefIndex: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [H256, Option<u32>]>;484 /**485 * Remove a proposal.486 * 487 * The dispatch origin of this call must be `CancelProposalOrigin`.488 * 489 * - `prop_index`: The index of the proposal to cancel.490 * 491 * Weight: `O(p)` where `p = PublicProps::<T>::decode_len()`492 **/493 cancelProposal: AugmentedSubmittable<(propIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;494 /**495 * Remove a referendum.496 * 497 * The dispatch origin of this call must be _Root_.498 * 499 * - `ref_index`: The index of the referendum to cancel.500 * 501 * # Weight: `O(1)`.502 **/503 cancelReferendum: AugmentedSubmittable<(refIndex: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;504 /**505 * Clears all public proposals.506 * 507 * The dispatch origin of this call must be _Root_.508 * 509 * Weight: `O(1)`.510 **/511 clearPublicProposals: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;512 /**513 * Delegate the voting power (with some given conviction) of the sending account.514 * 515 * The balance delegated is locked for as long as it's delegated, and thereafter for the516 * time appropriate for the conviction's lock period.517 * 518 * The dispatch origin of this call must be _Signed_, and the signing account must either:519 * - be delegating already; or520 * - have no voting activity (if there is, then it will need to be removed/consolidated521 * through `reap_vote` or `unvote`).522 * 523 * - `to`: The account whose voting the `target` account's voting power will follow.524 * - `conviction`: The conviction that will be attached to the delegated votes. When the525 * account is undelegated, the funds will be locked for the corresponding period.526 * - `balance`: The amount of the account's balance to be used in delegating. This must not527 * be more than the account's current balance.528 * 529 * Emits `Delegated`.530 * 531 * Weight: `O(R)` where R is the number of referendums the voter delegating to has532 * voted on. Weight is charged as if maximum votes.533 **/534 delegate: AugmentedSubmittable<(to: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, conviction: PalletDemocracyConviction | 'None' | 'Locked1x' | 'Locked2x' | 'Locked3x' | 'Locked4x' | 'Locked5x' | 'Locked6x' | number | Uint8Array, balance: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletDemocracyConviction, u128]>;535 /**536 * Schedule an emergency cancellation of a referendum. Cannot happen twice to the same537 * referendum.538 * 539 * The dispatch origin of this call must be `CancellationOrigin`.540 * 541 * -`ref_index`: The index of the referendum to cancel.542 * 543 * Weight: `O(1)`.544 **/545 emergencyCancel: AugmentedSubmittable<(refIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;546 /**547 * Schedule a referendum to be tabled once it is legal to schedule an external548 * referendum.549 * 550 * The dispatch origin of this call must be `ExternalOrigin`.551 * 552 * - `proposal_hash`: The preimage hash of the proposal.553 **/554 externalPropose: AugmentedSubmittable<(proposal: FrameSupportPreimagesBounded | { Legacy: any } | { Inline: any } | { Lookup: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrameSupportPreimagesBounded]>;555 /**556 * Schedule a negative-turnout-bias referendum to be tabled next once it is legal to557 * schedule an external referendum.558 * 559 * The dispatch of this call must be `ExternalDefaultOrigin`.560 * 561 * - `proposal_hash`: The preimage hash of the proposal.562 * 563 * Unlike `external_propose`, blacklisting has no effect on this and it may replace a564 * pre-scheduled `external_propose` call.565 * 566 * Weight: `O(1)`567 **/568 externalProposeDefault: AugmentedSubmittable<(proposal: FrameSupportPreimagesBounded | { Legacy: any } | { Inline: any } | { Lookup: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrameSupportPreimagesBounded]>;569 /**570 * Schedule a majority-carries referendum to be tabled next once it is legal to schedule571 * an external referendum.572 * 573 * The dispatch of this call must be `ExternalMajorityOrigin`.574 * 575 * - `proposal_hash`: The preimage hash of the proposal.576 * 577 * Unlike `external_propose`, blacklisting has no effect on this and it may replace a578 * pre-scheduled `external_propose` call.579 * 580 * Weight: `O(1)`581 **/582 externalProposeMajority: AugmentedSubmittable<(proposal: FrameSupportPreimagesBounded | { Legacy: any } | { Inline: any } | { Lookup: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrameSupportPreimagesBounded]>;583 /**584 * Schedule the currently externally-proposed majority-carries referendum to be tabled585 * immediately. If there is no externally-proposed referendum currently, or if there is one586 * but it is not a majority-carries referendum then it fails.587 * 588 * The dispatch of this call must be `FastTrackOrigin`.589 * 590 * - `proposal_hash`: The hash of the current external proposal.591 * - `voting_period`: The period that is allowed for voting on this proposal. Increased to592 * Must be always greater than zero.593 * For `FastTrackOrigin` must be equal or greater than `FastTrackVotingPeriod`.594 * - `delay`: The number of block after voting has ended in approval and this should be595 * enacted. This doesn't have a minimum amount.596 * 597 * Emits `Started`.598 * 599 * Weight: `O(1)`600 **/601 fastTrack: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, votingPeriod: u32 | AnyNumber | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, u32, u32]>;602 /**603 * Propose a sensitive action to be taken.604 * 605 * The dispatch origin of this call must be _Signed_ and the sender must606 * have funds to cover the deposit.607 * 608 * - `proposal_hash`: The hash of the proposal preimage.609 * - `value`: The amount of deposit (must be at least `MinimumDeposit`).610 * 611 * Emits `Proposed`.612 **/613 propose: AugmentedSubmittable<(proposal: FrameSupportPreimagesBounded | { Legacy: any } | { Inline: any } | { Lookup: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [FrameSupportPreimagesBounded, Compact<u128>]>;614 /**615 * Remove a vote for a referendum.616 * 617 * If the `target` is equal to the signer, then this function is exactly equivalent to618 * `remove_vote`. If not equal to the signer, then the vote must have expired,619 * either because the referendum was cancelled, because the voter lost the referendum or620 * because the conviction period is over.621 * 622 * The dispatch origin of this call must be _Signed_.623 * 624 * - `target`: The account of the vote to be removed; this account must have voted for625 * referendum `index`.626 * - `index`: The index of referendum of the vote to be removed.627 * 628 * Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on.629 * Weight is calculated for the maximum number of vote.630 **/631 removeOtherVote: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u32]>;632 /**633 * Remove a vote for a referendum.634 * 635 * If:636 * - the referendum was cancelled, or637 * - the referendum is ongoing, or638 * - the referendum has ended such that639 * - the vote of the account was in opposition to the result; or640 * - there was no conviction to the account's vote; or641 * - the account made a split vote642 * ...then the vote is removed cleanly and a following call to `unlock` may result in more643 * funds being available.644 * 645 * If, however, the referendum has ended and:646 * - it finished corresponding to the vote of the account, and647 * - the account made a standard vote with conviction, and648 * - the lock period of the conviction is not over649 * ...then the lock will be aggregated into the overall account's lock, which may involve650 * *overlocking* (where the two locks are combined into a single lock that is the maximum651 * of both the amount locked and the time is it locked for).652 * 653 * The dispatch origin of this call must be _Signed_, and the signer must have a vote654 * registered for referendum `index`.655 * 656 * - `index`: The index of referendum of the vote to be removed.657 * 658 * Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on.659 * Weight is calculated for the maximum number of vote.660 **/661 removeVote: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;662 /**663 * Signals agreement with a particular proposal.664 * 665 * The dispatch origin of this call must be _Signed_ and the sender666 * must have funds to cover the deposit, equal to the original deposit.667 * 668 * - `proposal`: The index of the proposal to second.669 **/670 second: AugmentedSubmittable<(proposal: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;671 /**672 * Set or clear a metadata of a proposal or a referendum.673 * 674 * Parameters:675 * - `origin`: Must correspond to the `MetadataOwner`.676 * - `ExternalOrigin` for an external proposal with the `SuperMajorityApprove`677 * threshold.678 * - `ExternalDefaultOrigin` for an external proposal with the `SuperMajorityAgainst`679 * threshold.680 * - `ExternalMajorityOrigin` for an external proposal with the `SimpleMajority`681 * threshold.682 * - `Signed` by a creator for a public proposal.683 * - `Signed` to clear a metadata for a finished referendum.684 * - `Root` to set a metadata for an ongoing referendum.685 * - `owner`: an identifier of a metadata owner.686 * - `maybe_hash`: The hash of an on-chain stored preimage. `None` to clear a metadata.687 **/688 setMetadata: AugmentedSubmittable<(owner: PalletDemocracyMetadataOwner | { External: any } | { Proposal: any } | { Referendum: any } | string | Uint8Array, maybeHash: Option<H256> | null | Uint8Array | H256 | string) => SubmittableExtrinsic<ApiType>, [PalletDemocracyMetadataOwner, Option<H256>]>;689 /**690 * Undelegate the voting power of the sending account.691 * 692 * Tokens may be unlocked following once an amount of time consistent with the lock period693 * of the conviction with which the delegation was issued.694 * 695 * The dispatch origin of this call must be _Signed_ and the signing account must be696 * currently delegating.697 * 698 * Emits `Undelegated`.699 * 700 * Weight: `O(R)` where R is the number of referendums the voter delegating to has701 * voted on. Weight is charged as if maximum votes.702 **/703 undelegate: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;704 /**705 * Unlock tokens that have an expired lock.706 * 707 * The dispatch origin of this call must be _Signed_.708 * 709 * - `target`: The account to remove the lock on.710 * 711 * Weight: `O(R)` with R number of vote of target.712 **/713 unlock: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;714 /**715 * Veto and blacklist the external proposal hash.716 * 717 * The dispatch origin of this call must be `VetoOrigin`.718 * 719 * - `proposal_hash`: The preimage hash of the proposal to veto and blacklist.720 * 721 * Emits `Vetoed`.722 * 723 * Weight: `O(V + log(V))` where V is number of `existing vetoers`724 **/725 vetoExternal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;726 /**727 * Vote in a referendum. If `vote.is_aye()`, the vote is to enact the proposal;728 * otherwise it is a vote to keep the status quo.729 * 730 * The dispatch origin of this call must be _Signed_.731 * 732 * - `ref_index`: The index of the referendum to vote for.733 * - `vote`: The vote configuration.734 **/735 vote: AugmentedSubmittable<(refIndex: Compact<u32> | AnyNumber | Uint8Array, vote: PalletDemocracyVoteAccountVote | { Standard: any } | { Split: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletDemocracyVoteAccountVote]>;736 /**737 * Generic tx738 **/739 [key: string]: SubmittableExtrinsicFunction<ApiType>;740 };741 dmpQueue: {742 /**743 * Service a single overweight message.744 **/745 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;746 /**747 * Generic tx748 **/749 [key: string]: SubmittableExtrinsicFunction<ApiType>;750 };751 ethereum: {752 /**753 * Transact an Ethereum transaction.754 **/755 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;756 /**757 * Generic tx758 **/759 [key: string]: SubmittableExtrinsicFunction<ApiType>;760 };761 evm: {762 /**763 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.764 **/765 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>]>>]>;766 /**767 * Issue an EVM create operation. This is similar to a contract creation transaction in768 * Ethereum.769 **/770 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>]>>]>;771 /**772 * Issue an EVM create2 operation.773 **/774 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>]>>]>;775 /**776 * Withdraw balance from EVM into currency/balances pallet.777 **/778 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;779 /**780 * Generic tx781 **/782 [key: string]: SubmittableExtrinsicFunction<ApiType>;783 };784 evmContractHelpers: {785 /**786 * Migrate contract to use `SponsoringMode` storage instead of `SelfSponsoring`787 **/788 migrateFromSelfSponsoring: AugmentedSubmittable<(addresses: Vec<H160> | (H160 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<H160>]>;789 /**790 * Generic tx791 **/792 [key: string]: SubmittableExtrinsicFunction<ApiType>;793 };794 evmMigration: {795 /**796 * Start contract migration, inserts contract stub at target address,797 * and marks account as pending, allowing to insert storage798 **/799 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;800 /**801 * Finish contract migration, allows it to be called.802 * It is not possible to alter contract storage via [`Self::set_data`]803 * after this call.804 **/805 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;806 /**807 * Create ethereum events attached to the fake transaction808 **/809 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;810 /**811 * Create substrate events812 **/813 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;814 /**815 * Remove remark compatibility data leftovers816 **/817 removeRmrkData: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;818 /**819 * Insert items into contract storage, this method can be called820 * multiple times821 **/822 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;823 /**824 * Generic tx825 **/826 [key: string]: SubmittableExtrinsicFunction<ApiType>;827 };828 fellowshipCollective: {829 /**830 * Introduce a new member.831 * 832 * - `origin`: Must be the `AdminOrigin`.833 * - `who`: Account of non-member which will become a member.834 * - `rank`: The rank to give the new member.835 * 836 * Weight: `O(1)`837 **/838 addMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;839 /**840 * Remove votes from the given poll. It must have ended.841 * 842 * - `origin`: Must be `Signed` by any account.843 * - `poll_index`: Index of a poll which is completed and for which votes continue to844 * exist.845 * - `max`: Maximum number of vote items from remove in this call.846 * 847 * Transaction fees are waived if the operation is successful.848 * 849 * Weight `O(max)` (less if there are fewer items to remove than `max`).850 **/851 cleanupPoll: AugmentedSubmittable<(pollIndex: u32 | AnyNumber | Uint8Array, max: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;852 /**853 * Decrement the rank of an existing member by one. If the member is already at rank zero,854 * then they are removed entirely.855 * 856 * - `origin`: Must be the `AdminOrigin`.857 * - `who`: Account of existing member of rank greater than zero.858 * 859 * Weight: `O(1)`, less if the member's index is highest in its rank.860 **/861 demoteMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;862 /**863 * Increment the rank of an existing member by one.864 * 865 * - `origin`: Must be the `AdminOrigin`.866 * - `who`: Account of existing member.867 * 868 * Weight: `O(1)`869 **/870 promoteMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;871 /**872 * Remove the member entirely.873 * 874 * - `origin`: Must be the `AdminOrigin`.875 * - `who`: Account of existing member of rank greater than zero.876 * - `min_rank`: The rank of the member or greater.877 * 878 * Weight: `O(min_rank)`.879 **/880 removeMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, minRank: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u16]>;881 /**882 * Add an aye or nay vote for the sender to the given proposal.883 * 884 * - `origin`: Must be `Signed` by a member account.885 * - `poll`: Index of a poll which is ongoing.886 * - `aye`: `true` if the vote is to approve the proposal, `false` otherwise.887 * 888 * Transaction fees are be waived if the member is voting on any particular proposal889 * for the first time and the call is successful. Subsequent vote changes will charge a890 * fee.891 * 892 * Weight: `O(1)`, less if there was no previous vote on the poll by the member.893 **/894 vote: AugmentedSubmittable<(poll: u32 | AnyNumber | Uint8Array, aye: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;895 /**896 * Generic tx897 **/898 [key: string]: SubmittableExtrinsicFunction<ApiType>;899 };900 fellowshipReferenda: {901 /**902 * Cancel an ongoing referendum.903 * 904 * - `origin`: must be the `CancelOrigin`.905 * - `index`: The index of the referendum to be cancelled.906 * 907 * Emits `Cancelled`.908 **/909 cancel: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;910 /**911 * Cancel an ongoing referendum and slash the deposits.912 * 913 * - `origin`: must be the `KillOrigin`.914 * - `index`: The index of the referendum to be cancelled.915 * 916 * Emits `Killed` and `DepositSlashed`.917 **/918 kill: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;919 /**920 * Advance a referendum onto its next logical state. Only used internally.921 * 922 * - `origin`: must be `Root`.923 * - `index`: the referendum to be advanced.924 **/925 nudgeReferendum: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;926 /**927 * Advance a track onto its next logical state. Only used internally.928 * 929 * - `origin`: must be `Root`.930 * - `track`: the track to be advanced.931 * 932 * Action item for when there is now one fewer referendum in the deciding phase and the933 * `DecidingCount` is not yet updated. This means that we should either:934 * - begin deciding another referendum (and leave `DecidingCount` alone); or935 * - decrement `DecidingCount`.936 **/937 oneFewerDeciding: AugmentedSubmittable<(track: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u16]>;938 /**939 * Post the Decision Deposit for a referendum.940 * 941 * - `origin`: must be `Signed` and the account must have funds available for the942 * referendum's track's Decision Deposit.943 * - `index`: The index of the submitted referendum whose Decision Deposit is yet to be944 * posted.945 * 946 * Emits `DecisionDepositPlaced`.947 **/948 placeDecisionDeposit: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;949 /**950 * Refund the Decision Deposit for a closed referendum back to the depositor.951 * 952 * - `origin`: must be `Signed` or `Root`.953 * - `index`: The index of a closed referendum whose Decision Deposit has not yet been954 * refunded.955 * 956 * Emits `DecisionDepositRefunded`.957 **/958 refundDecisionDeposit: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;959 /**960 * Refund the Submission Deposit for a closed referendum back to the depositor.961 * 962 * - `origin`: must be `Signed` or `Root`.963 * - `index`: The index of a closed referendum whose Submission Deposit has not yet been964 * refunded.965 * 966 * Emits `SubmissionDepositRefunded`.967 **/968 refundSubmissionDeposit: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;969 /**970 * Set or clear metadata of a referendum.971 * 972 * Parameters:973 * - `origin`: Must be `Signed` by a creator of a referendum or by anyone to clear a974 * metadata of a finished referendum.975 * - `index`: The index of a referendum to set or clear metadata for.976 * - `maybe_hash`: The hash of an on-chain stored preimage. `None` to clear a metadata.977 **/978 setMetadata: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array, maybeHash: Option<H256> | null | Uint8Array | H256 | string) => SubmittableExtrinsic<ApiType>, [u32, Option<H256>]>;979 /**980 * Propose a referendum on a privileged action.981 * 982 * - `origin`: must be `SubmitOrigin` and the account must have `SubmissionDeposit` funds983 * available.984 * - `proposal_origin`: The origin from which the proposal should be executed.985 * - `proposal`: The proposal.986 * - `enactment_moment`: The moment that the proposal should be enacted.987 * 988 * Emits `Submitted`.989 **/990 submit: AugmentedSubmittable<(proposalOrigin: OpalRuntimeOriginCaller | { system: any } | { Void: any } | { Council: any } | { TechnicalCommittee: any } | { PolkadotXcm: any } | { CumulusXcm: any } | { Origins: any } | { Ethereum: any } | string | Uint8Array, proposal: FrameSupportPreimagesBounded | { Legacy: any } | { Inline: any } | { Lookup: any } | string | Uint8Array, enactmentMoment: FrameSupportScheduleDispatchTime | { At: any } | { After: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeOriginCaller, FrameSupportPreimagesBounded, FrameSupportScheduleDispatchTime]>;991 /**992 * Generic tx993 **/994 [key: string]: SubmittableExtrinsicFunction<ApiType>;995 };996 foreignAssets: {997 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]>;998 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]>;999 /**1000 * Generic tx1001 **/1002 [key: string]: SubmittableExtrinsicFunction<ApiType>;1003 };1004 identity: {1005 /**1006 * Add a registrar to the system.1007 * 1008 * The dispatch origin for this call must be `T::RegistrarOrigin`.1009 * 1010 * - `account`: the account of the registrar.1011 * 1012 * Emits `RegistrarAdded` if successful.1013 * 1014 * # <weight>1015 * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).1016 * - One storage mutation (codec `O(R)`).1017 * - One event.1018 * # </weight>1019 **/1020 addRegistrar: AugmentedSubmittable<(account: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1021 /**1022 * Add the given account to the sender's subs.1023 * 1024 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated1025 * to the sender.1026 * 1027 * The dispatch origin for this call must be _Signed_ and the sender must have a registered1028 * sub identity of `sub`.1029 **/1030 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]>;1031 /**1032 * Cancel a previous request.1033 * 1034 * Payment: A previously reserved deposit is returned on success.1035 * 1036 * The dispatch origin for this call must be _Signed_ and the sender must have a1037 * registered identity.1038 * 1039 * - `reg_index`: The index of the registrar whose judgement is no longer requested.1040 * 1041 * Emits `JudgementUnrequested` if successful.1042 * 1043 * # <weight>1044 * - `O(R + X)`.1045 * - One balance-reserve operation.1046 * - One storage mutation `O(R + X)`.1047 * - One event1048 * # </weight>1049 **/1050 cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1051 /**1052 * Clear an account's identity info and all sub-accounts and return all deposits.1053 * 1054 * Payment: All reserved balances on the account are returned.1055 * 1056 * The dispatch origin for this call must be _Signed_ and the sender must have a registered1057 * identity.1058 * 1059 * Emits `IdentityCleared` if successful.1060 * 1061 * # <weight>1062 * - `O(R + S + X)`1063 * - where `R` registrar-count (governance-bounded).1064 * - where `S` subs-count (hard- and deposit-bounded).1065 * - where `X` additional-field-count (deposit-bounded and code-bounded).1066 * - One balance-unreserve operation.1067 * - `2` storage reads and `S + 2` storage deletions.1068 * - One event.1069 * # </weight>1070 **/1071 clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1072 /**1073 * Set identities to be associated with the provided accounts as force origin.1074 * 1075 * This is not meant to operate in tandem with the identity pallet as is,1076 * and be instead used to keep identities made and verified externally,1077 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.1078 **/1079 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]>>]>;1080 /**1081 * Remove identities associated with the provided accounts as force origin.1082 * 1083 * This is not meant to operate in tandem with the identity pallet as is,1084 * and be instead used to keep identities made and verified externally,1085 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.1086 **/1087 forceRemoveIdentities: AugmentedSubmittable<(identities: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;1088 /**1089 * Set sub-identities to be associated with the provided accounts as force origin.1090 * 1091 * This is not meant to operate in tandem with the identity pallet as is,1092 * and be instead used to keep identities made and verified externally,1093 * forbidden from interacting with an ordinary user, since it ignores any safety mechanism.1094 **/1095 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]>>]>]>>]>;1096 /**1097 * Remove an account's identity and sub-account information and slash the deposits.1098 * 1099 * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by1100 * `Slash`. Verification request deposits are not returned; they should be cancelled1101 * manually using `cancel_request`.1102 * 1103 * The dispatch origin for this call must match `T::ForceOrigin`.1104 * 1105 * - `target`: the account whose identity the judgement is upon. This must be an account1106 * with a registered identity.1107 * 1108 * Emits `IdentityKilled` if successful.1109 * 1110 * # <weight>1111 * - `O(R + S + X)`.1112 * - One balance-reserve operation.1113 * - `S + 2` storage mutations.1114 * - One event.1115 * # </weight>1116 **/1117 killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1118 /**1119 * Provide a judgement for an account's identity.1120 * 1121 * The dispatch origin for this call must be _Signed_ and the sender must be the account1122 * of the registrar whose index is `reg_index`.1123 * 1124 * - `reg_index`: the index of the registrar whose judgement is being made.1125 * - `target`: the account whose identity the judgement is upon. This must be an account1126 * with a registered identity.1127 * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.1128 * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.1129 * 1130 * Emits `JudgementGiven` if successful.1131 * 1132 * # <weight>1133 * - `O(R + X)`.1134 * - One balance-transfer operation.1135 * - Up to one account-lookup operation.1136 * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.1137 * - One event.1138 * # </weight>1139 **/1140 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]>;1141 /**1142 * Remove the sender as a sub-account.1143 * 1144 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated1145 * to the sender (*not* the original depositor).1146 * 1147 * The dispatch origin for this call must be _Signed_ and the sender must have a registered1148 * super-identity.1149 * 1150 * NOTE: This should not normally be used, but is provided in the case that the non-1151 * controller of an account is maliciously registered as a sub-account.1152 **/1153 quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1154 /**1155 * Remove the given account from the sender's subs.1156 * 1157 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated1158 * to the sender.1159 * 1160 * The dispatch origin for this call must be _Signed_ and the sender must have a registered1161 * sub identity of `sub`.1162 **/1163 removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1164 /**1165 * Alter the associated name of the given sub-account.1166 * 1167 * The dispatch origin for this call must be _Signed_ and the sender must have a registered1168 * sub identity of `sub`.1169 **/1170 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]>;1171 /**1172 * Request a judgement from a registrar.1173 * 1174 * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement1175 * given.1176 * 1177 * The dispatch origin for this call must be _Signed_ and the sender must have a1178 * registered identity.1179 * 1180 * - `reg_index`: The index of the registrar whose judgement is requested.1181 * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:1182 * 1183 * ```nocompile1184 * Self::registrars().get(reg_index).unwrap().fee1185 * ```1186 * 1187 * Emits `JudgementRequested` if successful.1188 * 1189 * # <weight>1190 * - `O(R + X)`.1191 * - One balance-reserve operation.1192 * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.1193 * - One event.1194 * # </weight>1195 **/1196 requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;1197 /**1198 * Change the account associated with a registrar.1199 * 1200 * The dispatch origin for this call must be _Signed_ and the sender must be the account1201 * of the registrar whose index is `index`.1202 * 1203 * - `index`: the index of the registrar whose fee is to be set.1204 * - `new`: the new account ID.1205 * 1206 * # <weight>1207 * - `O(R)`.1208 * - One storage mutation `O(R)`.1209 * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)1210 * # </weight>1211 **/1212 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]>;1213 /**1214 * Set the fee required for a judgement to be requested from a registrar.1215 * 1216 * The dispatch origin for this call must be _Signed_ and the sender must be the account1217 * of the registrar whose index is `index`.1218 * 1219 * - `index`: the index of the registrar whose fee is to be set.1220 * - `fee`: the new fee.1221 * 1222 * # <weight>1223 * - `O(R)`.1224 * - One storage mutation `O(R)`.1225 * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)1226 * # </weight>1227 **/1228 setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;1229 /**1230 * Set the field information for a registrar.1231 * 1232 * The dispatch origin for this call must be _Signed_ and the sender must be the account1233 * of the registrar whose index is `index`.1234 * 1235 * - `index`: the index of the registrar whose fee is to be set.1236 * - `fields`: the fields that the registrar concerns themselves with.1237 * 1238 * # <weight>1239 * - `O(R)`.1240 * - One storage mutation `O(R)`.1241 * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)1242 * # </weight>1243 **/1244 setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;1245 /**1246 * Set an account's identity information and reserve the appropriate deposit.1247 * 1248 * If the account already has identity information, the deposit is taken as part payment1249 * for the new deposit.1250 * 1251 * The dispatch origin for this call must be _Signed_.1252 * 1253 * - `info`: The identity information.1254 * 1255 * Emits `IdentitySet` if successful.1256 * 1257 * # <weight>1258 * - `O(X + X' + R)`1259 * - where `X` additional-field-count (deposit-bounded and code-bounded)1260 * - where `R` judgements-count (registrar-count-bounded)1261 * - One balance reserve operation.1262 * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).1263 * - One event.1264 * # </weight>1265 **/1266 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]>;1267 /**1268 * Set the sub-accounts of the sender.1269 * 1270 * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned1271 * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.1272 * 1273 * The dispatch origin for this call must be _Signed_ and the sender must have a registered1274 * identity.1275 * 1276 * - `subs`: The identity's (new) sub-accounts.1277 * 1278 * # <weight>1279 * - `O(P + S)`1280 * - where `P` old-subs-count (hard- and deposit-bounded).1281 * - where `S` subs-count (hard- and deposit-bounded).1282 * - At most one balance operations.1283 * - DB:1284 * - `P + S` storage mutations (codec complexity `O(1)`)1285 * - One storage read (codec complexity `O(P)`).1286 * - One storage write (codec complexity `O(S)`).1287 * - One storage-exists (`IdentityOf::contains_key`).1288 * # </weight>1289 **/1290 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]>>]>;1291 /**1292 * Generic tx1293 **/1294 [key: string]: SubmittableExtrinsicFunction<ApiType>;1295 };1296 inflation: {1297 /**1298 * This method sets the inflation start date. Can be only called once.1299 * Inflation start block can be backdated and will catch up. The method will create Treasury1300 * account if it does not exist and perform the first inflation deposit.1301 * 1302 * # Permissions1303 * 1304 * * Root1305 * 1306 * # Arguments1307 * 1308 * * inflation_start_relay_block: The relay chain block at which inflation should start1309 **/1310 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1311 /**1312 * Generic tx1313 **/1314 [key: string]: SubmittableExtrinsicFunction<ApiType>;1315 };1316 maintenance: {1317 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1318 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1319 /**1320 * Execute a runtime call stored as a preimage.1321 * 1322 * `weight_bound` is the maximum weight that the caller is willing1323 * to allow the extrinsic to be executed with.1324 **/1325 executePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array, weightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, SpWeightsWeightV2Weight]>;1326 /**1327 * Generic tx1328 **/1329 [key: string]: SubmittableExtrinsicFunction<ApiType>;1330 };1331 parachainInfo: {1332 /**1333 * Generic tx1334 **/1335 [key: string]: SubmittableExtrinsicFunction<ApiType>;1336 };1337 parachainSystem: {1338 /**1339 * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied1340 * later.1341 * 1342 * The `check_version` parameter sets a boolean flag for whether or not the runtime's spec1343 * version and name should be verified on upgrade. Since the authorization only has a hash,1344 * it cannot actually perform the verification.1345 * 1346 * This call requires Root origin.1347 **/1348 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array, checkVersion: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, bool]>;1349 /**1350 * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.1351 * 1352 * If the authorization required a version check, this call will ensure the spec name1353 * remains unchanged and that the spec version has increased.1354 * 1355 * Note that this function will not apply the new `code`, but only attempt to schedule the1356 * upgrade with the Relay Chain.1357 * 1358 * All origins are allowed.1359 **/1360 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1361 /**1362 * Set the current validation data.1363 * 1364 * This should be invoked exactly once per block. It will panic at the finalization1365 * phase if the call was not invoked.1366 * 1367 * The dispatch origin for this call must be `Inherent`1368 * 1369 * As a side effect, this function upgrades the current validation function1370 * if the appropriate time has come.1371 **/1372 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;1373 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1374 /**1375 * Generic tx1376 **/1377 [key: string]: SubmittableExtrinsicFunction<ApiType>;1378 };1379 polkadotXcm: {1380 /**1381 * Execute an XCM message from a local, signed, origin.1382 * 1383 * An event is deposited indicating whether `msg` could be executed completely or only1384 * partially.1385 * 1386 * No more than `max_weight` will be used in its attempted execution. If this is less than the1387 * maximum amount of weight that the message could take to be executed, then no execution1388 * attempt will be made.1389 * 1390 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully1391 * to completion; only that *some* of it was executed.1392 **/1393 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array, maxWeight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, SpWeightsWeightV2Weight]>;1394 /**1395 * Set a safe XCM version (the version that XCM should be encoded with if the most recent1396 * version a destination can accept is unknown).1397 * 1398 * - `origin`: Must be an origin specified by AdminOrigin.1399 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.1400 **/1401 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;1402 /**1403 * Ask a location to notify us regarding their XCM version and any changes to it.1404 * 1405 * - `origin`: Must be an origin specified by AdminOrigin.1406 * - `location`: The location to which we should subscribe for XCM version notifications.1407 **/1408 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;1409 /**1410 * Set or unset the global suspension state of the XCM executor.1411 * 1412 * - `origin`: Must be an origin specified by AdminOrigin.1413 * - `suspended`: `true` to suspend, `false` to resume.1414 **/1415 forceSuspension: AugmentedSubmittable<(suspended: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [bool]>;1416 /**1417 * Require that a particular destination should no longer notify us regarding any XCM1418 * version changes.1419 * 1420 * - `origin`: Must be an origin specified by AdminOrigin.1421 * - `location`: The location to which we are currently subscribed for XCM version1422 * notifications which we no longer desire.1423 **/1424 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;1425 /**1426 * Extoll that a particular destination can be communicated with through a particular1427 * version of XCM.1428 * 1429 * - `origin`: Must be an origin specified by AdminOrigin.1430 * - `location`: The destination that is being described.1431 * - `xcm_version`: The latest version of XCM that `location` supports.1432 **/1433 forceXcmVersion: AugmentedSubmittable<(location: XcmV3MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV3MultiLocation, u32]>;1434 /**1435 * Transfer some assets from the local chain to the sovereign account of a destination1436 * chain and forward a notification XCM.1437 * 1438 * Fee payment on the destination side is made from the asset in the `assets` vector of1439 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight1440 * is needed than `weight_limit`, then the operation will fail and the assets send may be1441 * at risk.1442 * 1443 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.1444 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send1445 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.1446 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be1447 * an `AccountId32` value.1448 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the1449 * `dest` side.1450 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay1451 * fees.1452 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.1453 **/1454 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]>;1455 /**1456 * Teleport some assets from the local chain to some destination chain.1457 * 1458 * Fee payment on the destination side is made from the asset in the `assets` vector of1459 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight1460 * is needed than `weight_limit`, then the operation will fail and the assets send may be1461 * at risk.1462 * 1463 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.1464 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send1465 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.1466 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be1467 * an `AccountId32` value.1468 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the1469 * `dest` side. May not be empty.1470 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay1471 * fees.1472 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.1473 **/1474 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]>;1475 /**1476 * Transfer some assets from the local chain to the sovereign account of a destination1477 * chain and forward a notification XCM.1478 * 1479 * Fee payment on the destination side is made from the asset in the `assets` vector of1480 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,1481 * with all fees taken as needed from the asset.1482 * 1483 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.1484 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send1485 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.1486 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be1487 * an `AccountId32` value.1488 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the1489 * `dest` side.1490 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay1491 * fees.1492 **/1493 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]>;1494 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array, message: XcmVersionedXcm | { V2: any } | { V3: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;1495 /**1496 * Teleport some assets from the local chain to some destination chain.1497 * 1498 * Fee payment on the destination side is made from the asset in the `assets` vector of1499 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,1500 * with all fees taken as needed from the asset.1501 * 1502 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.1503 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send1504 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.1505 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be1506 * an `AccountId32` value.1507 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the1508 * `dest` side. May not be empty.1509 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay1510 * fees.1511 **/1512 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]>;1513 /**1514 * Generic tx1515 **/1516 [key: string]: SubmittableExtrinsicFunction<ApiType>;1517 };1518 preimage: {1519 /**1520 * Register a preimage on-chain.1521 * 1522 * If the preimage was previously requested, no fees or deposits are taken for providing1523 * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.1524 **/1525 notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1526 /**1527 * Request a preimage be uploaded to the chain without paying any fees or deposits.1528 * 1529 * If the preimage requests has already been provided on-chain, we unreserve any deposit1530 * a user may have paid, and take the control of the preimage out of their hands.1531 **/1532 requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;1533 /**1534 * Clear an unrequested preimage from the runtime storage.1535 * 1536 * If `len` is provided, then it will be a much cheaper operation.1537 * 1538 * - `hash`: The hash of the preimage to be removed from the store.1539 * - `len`: The length of the preimage of `hash`.1540 **/1541 unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;1542 /**1543 * Clear a previously made request for a preimage.1544 * 1545 * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.1546 **/1547 unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;1548 /**1549 * Generic tx1550 **/1551 [key: string]: SubmittableExtrinsicFunction<ApiType>;1552 };1553 scheduler: {1554 /**1555 * Cancel an anonymously scheduled task.1556 **/1557 cancel: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1558 /**1559 * Cancel a named scheduled task.1560 **/1561 cancelNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed]>;1562 /**1563 * Anonymously schedule a task.1564 **/1565 schedule: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;1566 /**1567 * Anonymously schedule a task after a delay.1568 **/1569 scheduleAfter: AugmentedSubmittable<(after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;1570 /**1571 * Schedule a named task.1572 **/1573 scheduleNamed: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;1574 /**1575 * Schedule a named task after a delay.1576 **/1577 scheduleNamedAfter: AugmentedSubmittable<(id: U8aFixed | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | Uint8Array | ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], priority: u8 | AnyNumber | Uint8Array, call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [U8aFixed, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;1578 /**1579 * Generic tx1580 **/1581 [key: string]: SubmittableExtrinsicFunction<ApiType>;1582 };1583 session: {1584 /**1585 * Removes any session key(s) of the function caller.1586 * 1587 * This doesn't take effect until the next session.1588 * 1589 * The dispatch origin of this function must be Signed and the account must be either be1590 * convertible to a validator ID using the chain's typical addressing system (this usually1591 * means being a controller account) or directly convertible into a validator ID (which1592 * usually means being a stash account).1593 * 1594 * ## Complexity1595 * - `O(1)` in number of key types. Actual cost depends on the number of length of1596 * `T::Keys::key_ids()` which is fixed.1597 **/1598 purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1599 /**1600 * Sets the session key(s) of the function caller to `keys`.1601 * Allows an account to set its session key prior to becoming a validator.1602 * This doesn't take effect until the next session.1603 * 1604 * The dispatch origin of this function must be signed.1605 * 1606 * ## Complexity1607 * - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is1608 * fixed.1609 **/1610 setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;1611 /**1612 * Generic tx1613 **/1614 [key: string]: SubmittableExtrinsicFunction<ApiType>;1615 };1616 stateTrieMigration: {1617 /**1618 * Continue the migration for the given `limits`.1619 * 1620 * The dispatch origin of this call can be any signed account.1621 * 1622 * This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,1623 * Upon successful execution, the transaction fee is returned.1624 * 1625 * The (potentially over-estimated) of the byte length of all the data read must be1626 * provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing1627 * that executing the current `MigrationTask` with the given `limits` will not exceed1628 * `real_size_upper` bytes of read data.1629 * 1630 * The `witness_task` is merely a helper to prevent the caller from being slashed or1631 * generally trigger a migration that they do not intend. This parameter is just a message1632 * from caller, saying that they believed `witness_task` was the last state of the1633 * migration, and they only wish for their transaction to do anything, if this assumption1634 * holds. In case `witness_task` does not match, the transaction fails.1635 * 1636 * Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the1637 * recommended way of doing this is to pass a `limit` that only bounds `count`, as the1638 * `size` limit can always be overwritten.1639 **/1640 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]>;1641 /**1642 * Control the automatic migration.1643 * 1644 * The dispatch origin of this call must be [`Config::ControlOrigin`].1645 **/1646 controlAutoMigration: AugmentedSubmittable<(maybeConfig: Option<PalletStateTrieMigrationMigrationLimits> | null | Uint8Array | PalletStateTrieMigrationMigrationLimits | { size_?: any; item?: any } | string) => SubmittableExtrinsic<ApiType>, [Option<PalletStateTrieMigrationMigrationLimits>]>;1647 /**1648 * Forcefully set the progress the running migration.1649 * 1650 * This is only useful in one case: the next key to migrate is too big to be migrated with1651 * a signed account, in a parachain context, and we simply want to skip it. A reasonable1652 * example of this would be `:code:`, which is both very expensive to migrate, and commonly1653 * used, so probably it is already migrated.1654 * 1655 * In case you mess things up, you can also, in principle, use this to reset the migration1656 * process.1657 **/1658 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]>;1659 /**1660 * Migrate the list of child keys by iterating each of them one by one.1661 * 1662 * All of the given child keys must be present under one `child_root`.1663 * 1664 * This does not affect the global migration process tracker ([`MigrationProcess`]), and1665 * should only be used in case any keys are leftover due to a bug.1666 **/1667 migrateCustomChild: AugmentedSubmittable<(root: Bytes | string | Uint8Array, childKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[], totalSize: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Vec<Bytes>, u32]>;1668 /**1669 * Migrate the list of top keys by iterating each of them one by one.1670 * 1671 * This does not affect the global migration process tracker ([`MigrationProcess`]), and1672 * should only be used in case any keys are leftover due to a bug.1673 **/1674 migrateCustomTop: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[], witnessSize: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>, u32]>;1675 /**1676 * Set the maximum limit of the signed migration.1677 **/1678 setSignedMaxLimits: AugmentedSubmittable<(limits: PalletStateTrieMigrationMigrationLimits | { size_?: any; item?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletStateTrieMigrationMigrationLimits]>;1679 /**1680 * Generic tx1681 **/1682 [key: string]: SubmittableExtrinsicFunction<ApiType>;1683 };1684 structure: {1685 /**1686 * Generic tx1687 **/1688 [key: string]: SubmittableExtrinsicFunction<ApiType>;1689 };1690 sudo: {1691 /**1692 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo1693 * key.1694 * 1695 * The dispatch origin for this call must be _Signed_.1696 * 1697 * ## Complexity1698 * - O(1).1699 **/1700 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1701 /**1702 * Authenticates the sudo key and dispatches a function call with `Root` origin.1703 * 1704 * The dispatch origin for this call must be _Signed_.1705 * 1706 * ## Complexity1707 * - O(1).1708 **/1709 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;1710 /**1711 * Authenticates the sudo key and dispatches a function call with `Signed` origin from1712 * a given account.1713 * 1714 * The dispatch origin for this call must be _Signed_.1715 * 1716 * ## Complexity1717 * - O(1).1718 **/1719 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]>;1720 /**1721 * Authenticates the sudo key and dispatches a function call with `Root` origin.1722 * This function does not check the weight of the call, and instead allows the1723 * Sudo user to specify the weight of the call.1724 * 1725 * The dispatch origin for this call must be _Signed_.1726 * 1727 * ## Complexity1728 * - O(1).1729 **/1730 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;1731 /**1732 * Generic tx1733 **/1734 [key: string]: SubmittableExtrinsicFunction<ApiType>;1735 };1736 system: {1737 /**1738 * Kill all storage items with a key that starts with the given prefix.1739 * 1740 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1741 * the prefix we are removing to accurately calculate the weight of this function.1742 **/1743 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1744 /**1745 * Kill some items from storage.1746 **/1747 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1748 /**1749 * Make some on-chain remark.1750 * 1751 * - `O(1)`1752 **/1753 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1754 /**1755 * Make some on-chain remark and emit event.1756 **/1757 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1758 /**1759 * Set the new runtime code.1760 **/1761 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1762 /**1763 * Set the new runtime code without doing any checks of the given `code`.1764 **/1765 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1766 /**1767 * Set the number of pages in the WebAssembly environment's heap.1768 **/1769 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1770 /**1771 * Set some items of storage.1772 **/1773 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1774 /**1775 * Generic tx1776 **/1777 [key: string]: SubmittableExtrinsicFunction<ApiType>;1778 };1779 technicalCommittee: {1780 /**1781 * Close a vote that is either approved, disapproved or whose voting period has ended.1782 * 1783 * May be called by any signed account in order to finish voting and close the proposal.1784 * 1785 * If called before the end of the voting period it will only close the vote if it is1786 * has enough votes to be approved or disapproved.1787 * 1788 * If called after the end of the voting period abstentions are counted as rejections1789 * unless there is a prime member set and the prime member cast an approval.1790 * 1791 * If the close operation completes successfully with disapproval, the transaction fee will1792 * be waived. Otherwise execution of the approved operation will be charged to the caller.1793 * 1794 * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed1795 * proposal.1796 * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via1797 * `storage::read` so it is `size_of::<u32>() == 4` larger than the pure length.1798 * 1799 * ## Complexity1800 * - `O(B + M + P1 + P2)` where:1801 * - `B` is `proposal` size in bytes (length-fee-bounded)1802 * - `M` is members-count (code- and governance-bounded)1803 * - `P1` is the complexity of `proposal` preimage.1804 * - `P2` is proposal-count (code-bounded)1805 **/1806 close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, proposalWeightBound: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, SpWeightsWeightV2Weight, Compact<u32>]>;1807 /**1808 * Disapprove a proposal, close, and remove it from the system, regardless of its current1809 * state.1810 * 1811 * Must be called by the Root origin.1812 * 1813 * Parameters:1814 * * `proposal_hash`: The hash of the proposal that should be disapproved.1815 * 1816 * ## Complexity1817 * O(P) where P is the number of max proposals1818 **/1819 disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;1820 /**1821 * Dispatch a proposal from a member using the `Member` origin.1822 * 1823 * Origin must be a member of the collective.1824 * 1825 * ## Complexity:1826 * - `O(B + M + P)` where:1827 * - `B` is `proposal` size in bytes (length-fee-bounded)1828 * - `M` members-count (code-bounded)1829 * - `P` complexity of dispatching `proposal`1830 **/1831 execute: AugmentedSubmittable<(proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Compact<u32>]>;1832 /**1833 * Add a new proposal to either be voted on or executed directly.1834 * 1835 * Requires the sender to be member.1836 * 1837 * `threshold` determines whether `proposal` is executed directly (`threshold < 2`)1838 * or put up for voting.1839 * 1840 * ## Complexity1841 * - `O(B + M + P1)` or `O(B + M + P2)` where:1842 * - `B` is `proposal` size in bytes (length-fee-bounded)1843 * - `M` is members-count (code- and governance-bounded)1844 * - branching is influenced by `threshold` where:1845 * - `P1` is proposal execution complexity (`threshold < 2`)1846 * - `P2` is proposals-count (code-bounded) (`threshold >= 2`)1847 **/1848 propose: AugmentedSubmittable<(threshold: Compact<u32> | AnyNumber | Uint8Array, proposal: Call | IMethod | string | Uint8Array, lengthBound: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Call, Compact<u32>]>;1849 /**1850 * Set the collective's membership.1851 * 1852 * - `new_members`: The new member list. Be nice to the chain and provide it sorted.1853 * - `prime`: The prime member whose vote sets the default.1854 * - `old_count`: The upper bound for the previous number of members in storage. Used for1855 * weight estimation.1856 * 1857 * The dispatch of this call must be `SetMembersOrigin`.1858 * 1859 * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but1860 * the weight estimations rely on it to estimate dispatchable weight.1861 * 1862 * # WARNING:1863 * 1864 * The `pallet-collective` can also be managed by logic outside of the pallet through the1865 * implementation of the trait [`ChangeMembers`].1866 * Any call to `set_members` must be careful that the member set doesn't get out of sync1867 * with other logic managing the member set.1868 * 1869 * ## Complexity:1870 * - `O(MP + N)` where:1871 * - `M` old-members-count (code- and governance-bounded)1872 * - `N` new-members-count (code- and governance-bounded)1873 * - `P` proposals-count (code-bounded)1874 **/1875 setMembers: AugmentedSubmittable<(newMembers: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[], prime: Option<AccountId32> | null | Uint8Array | AccountId32 | string, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>, Option<AccountId32>, u32]>;1876 /**1877 * Add an aye or nay vote for the sender to the given proposal.1878 * 1879 * Requires the sender to be a member.1880 * 1881 * Transaction fees will be waived if the member is voting on any particular proposal1882 * for the first time and the call is successful. Subsequent vote changes will charge a1883 * fee.1884 * ## Complexity1885 * - `O(M)` where `M` is members-count (code- and governance-bounded)1886 **/1887 vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact<u32> | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256, Compact<u32>, bool]>;1888 /**1889 * Generic tx1890 **/1891 [key: string]: SubmittableExtrinsicFunction<ApiType>;1892 };1893 technicalCommitteeMembership: {1894 /**1895 * Add a member `who` to the set.1896 * 1897 * May only be called from `T::AddOrigin`.1898 **/1899 addMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1900 /**1901 * Swap out the sending member for some other key `new`.1902 * 1903 * May only be called from `Signed` origin of a current member.1904 * 1905 * Prime membership is passed from the origin account to `new`, if extant.1906 **/1907 changeKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1908 /**1909 * Remove the prime member if it exists.1910 * 1911 * May only be called from `T::PrimeOrigin`.1912 **/1913 clearPrime: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1914 /**1915 * Remove a member `who` from the set.1916 * 1917 * May only be called from `T::RemoveOrigin`.1918 **/1919 removeMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1920 /**1921 * Change the membership to a new set, disregarding the existing membership. Be nice and1922 * pass `members` pre-sorted.1923 * 1924 * May only be called from `T::ResetOrigin`.1925 **/1926 resetMembers: AugmentedSubmittable<(members: Vec<AccountId32> | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<AccountId32>]>;1927 /**1928 * Set the prime member. Must be a current member.1929 * 1930 * May only be called from `T::PrimeOrigin`.1931 **/1932 setPrime: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1933 /**1934 * Swap out one member `remove` for another `add`.1935 * 1936 * May only be called from `T::SwapOrigin`.1937 * 1938 * Prime membership is *not* passed from `remove` to `add`, if extant.1939 **/1940 swapMember: AugmentedSubmittable<(remove: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, add: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress]>;1941 /**1942 * Generic tx1943 **/1944 [key: string]: SubmittableExtrinsicFunction<ApiType>;1945 };1946 testUtils: {1947 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1948 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1949 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1950 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1951 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1952 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1953 /**1954 * Generic tx1955 **/1956 [key: string]: SubmittableExtrinsicFunction<ApiType>;1957 };1958 timestamp: {1959 /**1960 * Set the current time.1961 * 1962 * This call should be invoked exactly once per block. It will panic at the finalization1963 * phase, if this call hasn't been invoked by that time.1964 * 1965 * The timestamp should be greater than the previous one by the amount specified by1966 * `MinimumPeriod`.1967 * 1968 * The dispatch origin for this call must be `Inherent`.1969 * 1970 * ## Complexity1971 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1972 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1973 * `on_finalize`)1974 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1975 **/1976 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1977 /**1978 * Generic tx1979 **/1980 [key: string]: SubmittableExtrinsicFunction<ApiType>;1981 };1982 tokens: {1983 /**1984 * Exactly as `transfer`, except the origin must be root and the source1985 * account may be specified.1986 * 1987 * The dispatch origin for this call must be _Root_.1988 * 1989 * - `source`: The sender of the transfer.1990 * - `dest`: The recipient of the transfer.1991 * - `currency_id`: currency type.1992 * - `amount`: free balance amount to tranfer.1993 **/1994 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>]>;1995 /**1996 * Set the balances of a given account.1997 * 1998 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1999 * will also decrease the total issuance of the system2000 * (`TotalIssuance`). If the new free or reserved balance is below the2001 * existential deposit, it will reap the `AccountInfo`.2002 * 2003 * The dispatch origin for this call is `root`.2004 **/2005 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>]>;2006 /**2007 * Transfer some liquid free balance to another account.2008 * 2009 * `transfer` will set the `FreeBalance` of the sender and receiver.2010 * It will decrease the total issuance of the system by the2011 * `TransferFee`. If the sender's account is below the existential2012 * deposit as a result of the transfer, the account will be reaped.2013 * 2014 * The dispatch origin for this call must be `Signed` by the2015 * transactor.2016 * 2017 * - `dest`: The recipient of the transfer.2018 * - `currency_id`: currency type.2019 * - `amount`: free balance amount to tranfer.2020 **/2021 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>]>;2022 /**2023 * Transfer all remaining balance to the given account.2024 * 2025 * NOTE: This function only attempts to transfer _transferable_2026 * balances. This means that any locked, reserved, or existential2027 * deposits (when `keep_alive` is `true`), will not be transferred by2028 * this function. To ensure that this function results in a killed2029 * account, you might need to prepare the account by removing any2030 * reference counters, storage deposits, etc...2031 * 2032 * The dispatch origin for this call must be `Signed` by the2033 * transactor.2034 * 2035 * - `dest`: The recipient of the transfer.2036 * - `currency_id`: currency type.2037 * - `keep_alive`: A boolean to determine if the `transfer_all`2038 * operation should send all of the funds the account has, causing2039 * the sender account to be killed (false), or transfer everything2040 * except at least the existential deposit, which will guarantee to2041 * keep the sender account alive (true).2042 **/2043 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]>;2044 /**2045 * Same as the [`transfer`] call, but with a check that the transfer2046 * will not kill the origin account.2047 * 2048 * 99% of the time you want [`transfer`] instead.2049 * 2050 * The dispatch origin for this call must be `Signed` by the2051 * transactor.2052 * 2053 * - `dest`: The recipient of the transfer.2054 * - `currency_id`: currency type.2055 * - `amount`: free balance amount to tranfer.2056 **/2057 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>]>;2058 /**2059 * Generic tx2060 **/2061 [key: string]: SubmittableExtrinsicFunction<ApiType>;2062 };2063 treasury: {2064 /**2065 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary2066 * and the original deposit will be returned.2067 * 2068 * May only be called from `T::ApproveOrigin`.2069 * 2070 * ## Complexity2071 * - O(1).2072 **/2073 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;2074 /**2075 * Put forward a suggestion for spending. A deposit proportional to the value2076 * is reserved and slashed if the proposal is rejected. It is returned once the2077 * proposal is awarded.2078 * 2079 * ## Complexity2080 * - O(1)2081 **/2082 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]>;2083 /**2084 * Reject a proposed spend. The original deposit will be slashed.2085 * 2086 * May only be called from `T::RejectOrigin`.2087 * 2088 * ## Complexity2089 * - O(1)2090 **/2091 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;2092 /**2093 * Force a previously approved proposal to be removed from the approval queue.2094 * The original deposit will no longer be returned.2095 * 2096 * May only be called from `T::RejectOrigin`.2097 * - `proposal_id`: The index of a proposal2098 * 2099 * ## Complexity2100 * - O(A) where `A` is the number of approvals2101 * 2102 * Errors:2103 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,2104 * i.e., the proposal has not been approved. This could also mean the proposal does not2105 * exist altogether, thus there is no way it would have been approved in the first place.2106 **/2107 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;2108 /**2109 * Propose and approve a spend of treasury funds.2110 * 2111 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.2112 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.2113 * - `beneficiary`: The destination account for the transfer.2114 * 2115 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the2116 * beneficiary.2117 **/2118 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]>;2119 /**2120 * Generic tx2121 **/2122 [key: string]: SubmittableExtrinsicFunction<ApiType>;2123 };2124 unique: {2125 /**2126 * Add an admin to a collection.2127 * 2128 * NFT Collection can be controlled by multiple admin addresses2129 * (some which can also be servers, for example). Admins can issue2130 * and burn NFTs, as well as add and remove other admins,2131 * but cannot change NFT or Collection ownership.2132 * 2133 * # Permissions2134 * 2135 * * Collection owner2136 * * Collection admin2137 * 2138 * # Arguments2139 * 2140 * * `collection_id`: ID of the Collection to add an admin for.2141 * * `new_admin`: Address of new admin to add.2142 **/2143 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;2144 /**2145 * Add an address to allow list.2146 * 2147 * # Permissions2148 * 2149 * * Collection owner2150 * * Collection admin2151 * 2152 * # Arguments2153 * 2154 * * `collection_id`: ID of the modified collection.2155 * * `address`: ID of the address to be added to the allowlist.2156 **/2157 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;2158 /**2159 * Allow a non-permissioned address to transfer or burn an item.2160 * 2161 * # Permissions2162 * 2163 * * Collection owner2164 * * Collection admin2165 * * Current item owner2166 * 2167 * # Arguments2168 * 2169 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.2170 * * `collection_id`: ID of the collection the item belongs to.2171 * * `item_id`: ID of the item transactions on which are now approved.2172 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).2173 * Set to 0 to revoke the approval.2174 **/2175 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]>;2176 /**2177 * Allow a non-permissioned address to transfer or burn an item from owner's eth mirror.2178 * 2179 * # Permissions2180 * 2181 * * Collection owner2182 * * Collection admin2183 * * Current item owner2184 * 2185 * # Arguments2186 * 2187 * * `from`: Owner's account eth mirror2188 * * `to`: Account to be approved to make specific transactions on non-owned tokens.2189 * * `collection_id`: ID of the collection the item belongs to.2190 * * `item_id`: ID of the item transactions on which are now approved.2191 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).2192 * Set to 0 to revoke the approval.2193 **/2194 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]>;2195 /**2196 * Destroy a token on behalf of the owner as a non-owner account.2197 * 2198 * See also: [`approve`][`Pallet::approve`].2199 * 2200 * After this method executes, one approval is removed from the total so that2201 * the approved address will not be able to transfer this item again from this owner.2202 * 2203 * # Permissions2204 * 2205 * * Collection owner2206 * * Collection admin2207 * * Current token owner2208 * * Address approved by current item owner2209 * 2210 * # Arguments2211 * 2212 * * `from`: The owner of the burning item.2213 * * `collection_id`: ID of the collection to which the item belongs.2214 * * `item_id`: ID of item to burn.2215 * * `value`: Number of pieces to burn.2216 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2217 * * Fungible Mode: The desired number of pieces to burn.2218 * * Re-Fungible Mode: The desired number of pieces to burn.2219 **/2220 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]>;2221 /**2222 * Destroy an item.2223 * 2224 * # Permissions2225 * 2226 * * Collection owner2227 * * Collection admin2228 * * Current item owner2229 * 2230 * # Arguments2231 * 2232 * * `collection_id`: ID of the collection to which the item belongs.2233 * * `item_id`: ID of item to burn.2234 * * `value`: Number of pieces of the item to destroy.2235 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2236 * * Fungible Mode: The desired number of pieces to burn.2237 * * Re-Fungible Mode: The desired number of pieces to burn.2238 **/2239 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;2240 /**2241 * Change the owner of the collection.2242 * 2243 * # Permissions2244 * 2245 * * Collection owner2246 * 2247 * # Arguments2248 * 2249 * * `collection_id`: ID of the modified collection.2250 * * `new_owner`: ID of the account that will become the owner.2251 **/2252 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;2253 /**2254 * Confirm own sponsorship of a collection, becoming the sponsor.2255 * 2256 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].2257 * Sponsor can pay the fees of a transaction instead of the sender,2258 * but only within specified limits.2259 * 2260 * # Permissions2261 * 2262 * * Sponsor-to-be2263 * 2264 * # Arguments2265 * 2266 * * `collection_id`: ID of the collection with the pending sponsor.2267 **/2268 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2269 /**2270 * Create a collection of tokens.2271 * 2272 * Each Token may have multiple properties encoded as an array of bytes2273 * of certain length. The initial owner of the collection is set2274 * to the address that signed the transaction and can be changed later.2275 * 2276 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.2277 * 2278 * # Permissions2279 * 2280 * * Anyone - becomes the owner of the new collection.2281 * 2282 * # Arguments2283 * 2284 * * `collection_name`: Wide-character string with collection name2285 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).2286 * * `collection_description`: Wide-character string with collection description2287 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).2288 * * `token_prefix`: Byte string containing the token prefix to mark a collection2289 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).2290 * * `mode`: Type of items stored in the collection and type dependent data.2291 * 2292 * returns collection ID2293 * 2294 * Deprecated: `create_collection_ex` is more up-to-date and advanced, prefer it instead.2295 **/2296 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]>;2297 /**2298 * Create a collection with explicit parameters.2299 * 2300 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.2301 * 2302 * # Permissions2303 * 2304 * * Anyone - becomes the owner of the new collection.2305 * 2306 * # Arguments2307 * 2308 * * `data`: Explicit data of a collection used for its creation.2309 **/2310 createCollectionEx: AugmentedSubmittable<(data: UpDataStructsCreateCollectionData | { mode?: any; access?: any; name?: any; description?: any; tokenPrefix?: any; limits?: any; permissions?: any; tokenPropertyPermissions?: any; properties?: any; adminList?: any; pendingSponsor?: any; flags?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [UpDataStructsCreateCollectionData]>;2311 /**2312 * Mint an item within a collection.2313 * 2314 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].2315 * 2316 * # Permissions2317 * 2318 * * Collection owner2319 * * Collection admin2320 * * Anyone if2321 * * Allow List is enabled, and2322 * * Address is added to allow list, and2323 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])2324 * 2325 * # Arguments2326 * 2327 * * `collection_id`: ID of the collection to which an item would belong.2328 * * `owner`: Address of the initial owner of the item.2329 * * `data`: Token data describing the item to store on chain.2330 **/2331 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]>;2332 /**2333 * Create multiple items within a collection.2334 * 2335 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].2336 * 2337 * # Permissions2338 * 2339 * * Collection owner2340 * * Collection admin2341 * * Anyone if2342 * * Allow List is enabled, and2343 * * Address is added to the allow list, and2344 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])2345 * 2346 * # Arguments2347 * 2348 * * `collection_id`: ID of the collection to which the tokens would belong.2349 * * `owner`: Address of the initial owner of the tokens.2350 * * `items_data`: Vector of data describing each item to be created.2351 **/2352 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>]>;2353 /**2354 * Create multiple items within a collection with explicitly specified initial parameters.2355 * 2356 * # Permissions2357 * 2358 * * Collection owner2359 * * Collection admin2360 * * Anyone if2361 * * Allow List is enabled, and2362 * * Address is added to allow list, and2363 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])2364 * 2365 * # Arguments2366 * 2367 * * `collection_id`: ID of the collection to which the tokens would belong.2368 * * `data`: Explicit item creation data.2369 **/2370 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;2371 /**2372 * Delete specified collection properties.2373 * 2374 * # Permissions2375 * 2376 * * Collection Owner2377 * * Collection Admin2378 * 2379 * # Arguments2380 * 2381 * * `collection_id`: ID of the modified collection.2382 * * `property_keys`: Vector of keys of the properties to be deleted.2383 * Keys support Latin letters, `-`, `_`, and `.` as symbols.2384 **/2385 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;2386 /**2387 * Delete specified token properties. Currently properties only work with NFTs.2388 * 2389 * # Permissions2390 * 2391 * * Depends on collection's token property permissions and specified property mutability:2392 * * Collection owner2393 * * Collection admin2394 * * Token owner2395 * 2396 * # Arguments2397 * 2398 * * `collection_id`: ID of the collection to which the token belongs.2399 * * `token_id`: ID of the modified token.2400 * * `property_keys`: Vector of keys of the properties to be deleted.2401 * Keys support Latin letters, `-`, `_`, and `.` as symbols.2402 **/2403 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;2404 /**2405 * Destroy a collection if no tokens exist within.2406 * 2407 * # Permissions2408 * 2409 * * Collection owner2410 * 2411 * # Arguments2412 * 2413 * * `collection_id`: Collection to destroy.2414 **/2415 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2416 /**2417 * Repairs a collection if the data was somehow corrupted.2418 * 2419 * # Arguments2420 * 2421 * * `collection_id`: ID of the collection to repair.2422 **/2423 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2424 /**2425 * Repairs a token if the data was somehow corrupted.2426 * 2427 * # Arguments2428 * 2429 * * `collection_id`: ID of the collection the item belongs to.2430 * * `item_id`: ID of the item.2431 **/2432 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;2433 /**2434 * Remove admin of a collection.2435 * 2436 * An admin address can remove itself. List of admins may become empty,2437 * in which case only Collection Owner will be able to add an Admin.2438 * 2439 * # Permissions2440 * 2441 * * Collection owner2442 * * Collection admin2443 * 2444 * # Arguments2445 * 2446 * * `collection_id`: ID of the collection to remove the admin for.2447 * * `account_id`: Address of the admin to remove.2448 **/2449 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;2450 /**2451 * Remove a collection's a sponsor, making everyone pay for their own transactions.2452 * 2453 * # Permissions2454 * 2455 * * Collection owner2456 * 2457 * # Arguments2458 * 2459 * * `collection_id`: ID of the collection with the sponsor to remove.2460 **/2461 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2462 /**2463 * Remove an address from allow list.2464 * 2465 * # Permissions2466 * 2467 * * Collection owner2468 * * Collection admin2469 * 2470 * # Arguments2471 * 2472 * * `collection_id`: ID of the modified collection.2473 * * `address`: ID of the address to be removed from the allowlist.2474 **/2475 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;2476 /**2477 * Re-partition a refungible token, while owning all of its parts/pieces.2478 * 2479 * # Permissions2480 * 2481 * * Token owner (must own every part)2482 * 2483 * # Arguments2484 * 2485 * * `collection_id`: ID of the collection the RFT belongs to.2486 * * `token_id`: ID of the RFT.2487 * * `amount`: New number of parts/pieces into which the token shall be partitioned.2488 **/2489 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;2490 /**2491 * Sets or unsets the approval of a given operator.2492 * 2493 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.2494 * 2495 * # Arguments2496 * 2497 * * `owner`: Token owner2498 * * `operator`: Operator2499 * * `approve`: Should operator status be granted or revoked?2500 **/2501 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;2502 /**2503 * Set specific limits of a collection. Empty, or None fields mean chain default.2504 * 2505 * # Permissions2506 * 2507 * * Collection owner2508 * * Collection admin2509 * 2510 * # Arguments2511 * 2512 * * `collection_id`: ID of the modified collection.2513 * * `new_limit`: New limits of the collection. Fields that are not set (None)2514 * will not overwrite the old ones.2515 **/2516 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]>;2517 /**2518 * Set specific permissions of a collection. Empty, or None fields mean chain default.2519 * 2520 * # Permissions2521 * 2522 * * Collection owner2523 * * Collection admin2524 * 2525 * # Arguments2526 * 2527 * * `collection_id`: ID of the modified collection.2528 * * `new_permission`: New permissions of the collection. Fields that are not set (None)2529 * will not overwrite the old ones.2530 **/2531 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;2532 /**2533 * Add or change collection properties.2534 * 2535 * # Permissions2536 * 2537 * * Collection owner2538 * * Collection admin2539 * 2540 * # Arguments2541 * 2542 * * `collection_id`: ID of the modified collection.2543 * * `properties`: Vector of key-value pairs stored as the collection's metadata.2544 * Keys support Latin letters, `-`, `_`, and `.` as symbols.2545 **/2546 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;2547 /**2548 * Set (invite) a new collection sponsor.2549 * 2550 * If successful, confirmation from the sponsor-to-be will be pending.2551 * 2552 * # Permissions2553 * 2554 * * Collection owner2555 * * Collection admin2556 * 2557 * # Arguments2558 * 2559 * * `collection_id`: ID of the modified collection.2560 * * `new_sponsor`: ID of the account of the sponsor-to-be.2561 **/2562 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;2563 /**2564 * Add or change token properties according to collection's permissions.2565 * Currently properties only work with NFTs.2566 * 2567 * # Permissions2568 * 2569 * * Depends on collection's token property permissions and specified property mutability:2570 * * Collection owner2571 * * Collection admin2572 * * Token owner2573 * 2574 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].2575 * 2576 * # Arguments2577 * 2578 * * `collection_id: ID of the collection to which the token belongs.2579 * * `token_id`: ID of the modified token.2580 * * `properties`: Vector of key-value pairs stored as the token's metadata.2581 * Keys support Latin letters, `-`, `_`, and `.` as symbols.2582 **/2583 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>]>;2584 /**2585 * Add or change token property permissions of a collection.2586 * 2587 * Without a permission for a particular key, a property with that key2588 * cannot be created in a token.2589 * 2590 * # Permissions2591 * 2592 * * Collection owner2593 * * Collection admin2594 * 2595 * # Arguments2596 * 2597 * * `collection_id`: ID of the modified collection.2598 * * `property_permissions`: Vector of permissions for property keys.2599 * Keys support Latin letters, `-`, `_`, and `.` as symbols.2600 **/2601 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;2602 /**2603 * Completely allow or disallow transfers for a particular collection.2604 * 2605 * # Permissions2606 * 2607 * * Collection owner2608 * 2609 * # Arguments2610 * 2611 * * `collection_id`: ID of the collection.2612 * * `value`: New value of the flag, are transfers allowed?2613 **/2614 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;2615 /**2616 * Change ownership of the token.2617 * 2618 * # Permissions2619 * 2620 * * Collection owner2621 * * Collection admin2622 * * Current token owner2623 * 2624 * # Arguments2625 * 2626 * * `recipient`: Address of token recipient.2627 * * `collection_id`: ID of the collection the item belongs to.2628 * * `item_id`: ID of the item.2629 * * Non-Fungible Mode: Required.2630 * * Fungible Mode: Ignored.2631 * * Re-Fungible Mode: Required.2632 * 2633 * * `value`: Amount to transfer.2634 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2635 * * Fungible Mode: The desired number of pieces to transfer.2636 * * Re-Fungible Mode: The desired number of pieces to transfer.2637 **/2638 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]>;2639 /**2640 * Change ownership of an item on behalf of the owner as a non-owner account.2641 * 2642 * See the [`approve`][`Pallet::approve`] method for additional information.2643 * 2644 * After this method executes, one approval is removed from the total so that2645 * the approved address will not be able to transfer this item again from this owner.2646 * 2647 * # Permissions2648 * 2649 * * Collection owner2650 * * Collection admin2651 * * Current item owner2652 * * Address approved by current item owner2653 * 2654 * # Arguments2655 * 2656 * * `from`: Address that currently owns the token.2657 * * `recipient`: Address of the new token-owner-to-be.2658 * * `collection_id`: ID of the collection the item.2659 * * `item_id`: ID of the item to be transferred.2660 * * `value`: Amount to transfer.2661 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2662 * * Fungible Mode: The desired number of pieces to transfer.2663 * * Re-Fungible Mode: The desired number of pieces to transfer.2664 **/2665 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]>;2666 /**2667 * Generic tx2668 **/2669 [key: string]: SubmittableExtrinsicFunction<ApiType>;2670 };2671 vesting: {2672 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2673 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;2674 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>]>;2675 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]>;2676 /**2677 * Generic tx2678 **/2679 [key: string]: SubmittableExtrinsicFunction<ApiType>;2680 };2681 xcmpQueue: {2682 /**2683 * Resumes all XCM executions for the XCMP queue.2684 * 2685 * Note that this function doesn't change the status of the in/out bound channels.2686 * 2687 * - `origin`: Must pass `ControllerOrigin`.2688 **/2689 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2690 /**2691 * Services a single overweight XCM.2692 * 2693 * - `origin`: Must pass `ExecuteOverweightOrigin`.2694 * - `index`: The index of the overweight XCM to service2695 * - `weight_limit`: The amount of weight that XCM execution may take.2696 * 2697 * Errors:2698 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.2699 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.2700 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.2701 * 2702 * Events:2703 * - `OverweightServiced`: On success.2704 **/2705 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, SpWeightsWeightV2Weight]>;2706 /**2707 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.2708 * 2709 * - `origin`: Must pass `ControllerOrigin`.2710 **/2711 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2712 /**2713 * Overwrites the number of pages of messages which must be in the queue after which we drop any further2714 * messages from the channel.2715 * 2716 * - `origin`: Must pass `Root`.2717 * - `new`: Desired value for `QueueConfigData.drop_threshold`2718 **/2719 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2720 /**2721 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that2722 * message sending may recommence after it has been suspended.2723 * 2724 * - `origin`: Must pass `Root`.2725 * - `new`: Desired value for `QueueConfigData.resume_threshold`2726 **/2727 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2728 /**2729 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to2730 * suspend their sending.2731 * 2732 * - `origin`: Must pass `Root`.2733 * - `new`: Desired value for `QueueConfigData.suspend_value`2734 **/2735 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2736 /**2737 * Overwrites the amount of remaining weight under which we stop processing messages.2738 * 2739 * - `origin`: Must pass `Root`.2740 * - `new`: Desired value for `QueueConfigData.threshold_weight`2741 **/2742 updateThresholdWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;2743 /**2744 * Overwrites the speed to which the available weight approaches the maximum weight.2745 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.2746 * 2747 * - `origin`: Must pass `Root`.2748 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.2749 **/2750 updateWeightRestrictDecay: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;2751 /**2752 * Overwrite the maximum amount of weight any individual message may consume.2753 * Messages above this weight go into the overweight queue and may only be serviced explicitly.2754 * 2755 * - `origin`: Must pass `Root`.2756 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.2757 **/2758 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [SpWeightsWeightV2Weight]>;2759 /**2760 * Generic tx2761 **/2762 [key: string]: SubmittableExtrinsicFunction<ApiType>;2763 };2764 xTokens: {2765 /**2766 * Transfer native currencies.2767 * 2768 * `dest_weight_limit` is the weight for XCM execution on the dest2769 * chain, and it would be charged from the transferred assets. If set2770 * below requirements, the execution may fail and assets wouldn't be2771 * received.2772 * 2773 * It's a no-op if any error on local XCM execution or message sending.2774 * Note sending assets out per se doesn't guarantee they would be2775 * received. Receiving depends on if the XCM message could be delivered2776 * by the network, and if the receiving chain would handle2777 * messages correctly.2778 **/2779 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]>;2780 /**2781 * Transfer `MultiAsset`.2782 * 2783 * `dest_weight_limit` is the weight for XCM execution on the dest2784 * chain, and it would be charged from the transferred assets. If set2785 * below requirements, the execution may fail and assets wouldn't be2786 * received.2787 * 2788 * It's a no-op if any error on local XCM execution or message sending.2789 * Note sending assets out per se doesn't guarantee they would be2790 * received. Receiving depends on if the XCM message could be delivered2791 * by the network, and if the receiving chain would handle2792 * messages correctly.2793 **/2794 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]>;2795 /**2796 * Transfer several `MultiAsset` specifying the item to be used as fee2797 * 2798 * `dest_weight_limit` is the weight for XCM execution on the dest2799 * chain, and it would be charged from the transferred assets. If set2800 * below requirements, the execution may fail and assets wouldn't be2801 * received.2802 * 2803 * `fee_item` is index of the MultiAssets that we want to use for2804 * payment2805 * 2806 * It's a no-op if any error on local XCM execution or message sending.2807 * Note sending assets out per se doesn't guarantee they would be2808 * received. Receiving depends on if the XCM message could be delivered2809 * by the network, and if the receiving chain would handle2810 * messages correctly.2811 **/2812 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]>;2813 /**2814 * Transfer `MultiAsset` specifying the fee and amount as separate.2815 * 2816 * `dest_weight_limit` is the weight for XCM execution on the dest2817 * chain, and it would be charged from the transferred assets. If set2818 * below requirements, the execution may fail and assets wouldn't be2819 * received.2820 * 2821 * `fee` is the multiasset to be spent to pay for execution in2822 * destination chain. Both fee and amount will be subtracted form the2823 * callers balance For now we only accept fee and asset having the same2824 * `MultiLocation` id.2825 * 2826 * If `fee` is not high enough to cover for the execution costs in the2827 * destination chain, then the assets will be trapped in the2828 * destination chain2829 * 2830 * It's a no-op if any error on local XCM execution or message sending.2831 * Note sending assets out per se doesn't guarantee they would be2832 * received. Receiving depends on if the XCM message could be delivered2833 * by the network, and if the receiving chain would handle2834 * messages correctly.2835 **/2836 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]>;2837 /**2838 * Transfer several currencies specifying the item to be used as fee2839 * 2840 * `dest_weight_limit` is the weight for XCM execution on the dest2841 * chain, and it would be charged from the transferred assets. If set2842 * below requirements, the execution may fail and assets wouldn't be2843 * received.2844 * 2845 * `fee_item` is index of the currencies tuple that we want to use for2846 * payment2847 * 2848 * It's a no-op if any error on local XCM execution or message sending.2849 * Note sending assets out per se doesn't guarantee they would be2850 * received. Receiving depends on if the XCM message could be delivered2851 * by the network, and if the receiving chain would handle2852 * messages correctly.2853 **/2854 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]>;2855 /**2856 * Transfer native currencies specifying the fee and amount as2857 * separate.2858 * 2859 * `dest_weight_limit` is the weight for XCM execution on the dest2860 * chain, and it would be charged from the transferred assets. If set2861 * below requirements, the execution may fail and assets wouldn't be2862 * received.2863 * 2864 * `fee` is the amount to be spent to pay for execution in destination2865 * chain. Both fee and amount will be subtracted form the callers2866 * balance.2867 * 2868 * If `fee` is not high enough to cover for the execution costs in the2869 * destination chain, then the assets will be trapped in the2870 * destination chain2871 * 2872 * It's a no-op if any error on local XCM execution or message sending.2873 * Note sending assets out per se doesn't guarantee they would be2874 * received. Receiving depends on if the XCM message could be delivered2875 * by the network, and if the receiving chain would handle2876 * messages correctly.2877 **/2878 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]>;2879 /**2880 * Generic tx2881 **/2882 [key: string]: SubmittableExtrinsicFunction<ApiType>;2883 };2884 } // AugmentedSubmittables2885} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts155.8 KiBsourcehistory