1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/submittable';78import type { ApiTypes, AugmentedSubmittable, SubmittableExtrinsic, SubmittableExtrinsicFunction } from '@polkadot/api-base/types';9import type { Data } from '@polkadot/types';10import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';11import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';12import type { AccountId32, Call, H160, H256, MultiAddress, Permill } from '@polkadot/types/interfaces/runtime';13import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OpalRuntimeRuntimeCommonSessionKeys, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletIdentityBitFlags, PalletIdentityIdentityInfo, PalletIdentityJudgement, PalletIdentityRegistration, RmrkTraitsNftAccountIdOrCollectionNftTuple, RmrkTraitsPartEquippableList, RmrkTraitsPartPartType, RmrkTraitsResourceBasicResource, RmrkTraitsResourceComposableResource, RmrkTraitsResourceResourceTypes, RmrkTraitsResourceSlotResource, RmrkTraitsTheme, SpRuntimeHeader, SpWeightsWeightV2Weight, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionPermissions, UpDataStructsCreateCollectionData, UpDataStructsCreateItemData, UpDataStructsCreateItemExData, UpDataStructsProperty, UpDataStructsPropertyKeyPermission, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAsset, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';1415export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;16export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;17export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1819declare module '@polkadot/api-base/types/submittable' {20 interface AugmentedSubmittables<ApiType extends ApiTypes> {21 appPromotion: {22 /**23 * Recalculates interest for the specified number of stakers.24 * If all stakers are not recalculated, the next call of the extrinsic25 * will continue the recalculation, from those stakers for whom this26 * was not perform in last call.27 * 28 * # Permissions29 * 30 * * Pallet admin31 * 32 * # Arguments33 * 34 * * `stakers_number`: the number of stakers for which recalculation will be performed35 **/36 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;37 /**38 * Sets an address as the the admin.39 * 40 * # Permissions41 * 42 * * Sudo43 * 44 * # Arguments45 * 46 * * `admin`: account of the new admin.47 **/48 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;49 /**50 * Sets the pallet to be the sponsor for the collection.51 * 52 * # Permissions53 * 54 * * Pallet admin55 * 56 * # Arguments57 * 58 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`59 **/60 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;61 /**62 * Sets the pallet to be the sponsor for the contract.63 * 64 * # Permissions65 * 66 * * Pallet admin67 * 68 * # Arguments69 * 70 * * `contract_id`: the contract address that will be sponsored by `pallet_id`71 **/72 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;73 /**74 * Stakes the amount of native tokens.75 * Sets `amount` to the locked state.76 * The maximum number of stakes for a staker is 10.77 * 78 * # Arguments79 * 80 * * `amount`: in native tokens.81 **/82 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;83 /**84 * Removes the pallet as the sponsor for the collection.85 * Returns [`NoPermission`][`Error::NoPermission`]86 * if the pallet wasn't the sponsor.87 * 88 * # Permissions89 * 90 * * Pallet admin91 * 92 * # Arguments93 * 94 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`95 **/96 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;97 /**98 * Removes the pallet as the sponsor for the contract.99 * Returns [`NoPermission`][`Error::NoPermission`]100 * if the pallet wasn't the sponsor.101 * 102 * # Permissions103 * 104 * * Pallet admin105 * 106 * # Arguments107 * 108 * * `contract_id`: the contract address that is sponsored by `pallet_id`109 **/110 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;111 /**112 * Unstakes all stakes.113 * Moves the sum of all stakes to the `reserved` state.114 * After the end of `PendingInterval` this sum becomes completely115 * free for further use.116 **/117 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;118 /**119 * Generic tx120 **/121 [key: string]: SubmittableExtrinsicFunction<ApiType>;122 };123 authorship: {124 /**125 * Provide a set of uncles.126 **/127 setUncles: AugmentedSubmittable<(newUncles: Vec<SpRuntimeHeader> | (SpRuntimeHeader | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<SpRuntimeHeader>]>;128 /**129 * Generic tx130 **/131 [key: string]: SubmittableExtrinsicFunction<ApiType>;132 };133 balances: {134 /**135 * Exactly as `transfer`, except the origin must be root and the source account may be136 * specified.137 * # <weight>138 * - Same as transfer, but additional read and write because the source account is not139 * assumed to be in the overlay.140 * # </weight>141 **/142 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>]>;143 /**144 * Unreserve some balance from a user by force.145 * 146 * Can only be called by ROOT.147 **/148 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;149 /**150 * Set the balances of a given account.151 * 152 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will153 * also alter the total issuance of the system (`TotalIssuance`) appropriately.154 * If the new free or reserved balance is below the existential deposit,155 * it will reset the account nonce (`frame_system::AccountNonce`).156 * 157 * The dispatch origin for this call is `root`.158 **/159 setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<u128> | AnyNumber | Uint8Array, newReserved: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>, Compact<u128>]>;160 /**161 * Transfer some liquid free balance to another account.162 * 163 * `transfer` will set the `FreeBalance` of the sender and receiver.164 * If the sender's account is below the existential deposit as a result165 * of the transfer, the account will be reaped.166 * 167 * The dispatch origin for this call must be `Signed` by the transactor.168 * 169 * # <weight>170 * - Dependent on arguments but not critical, given proper implementations for input config171 * types. See related functions below.172 * - It contains a limited number of reads and writes internally and no complex173 * computation.174 * 175 * Related functions:176 * 177 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.178 * - Transferring balances to accounts that did not exist before will cause179 * `T::OnNewAccount::on_new_account` to be called.180 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.181 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check182 * that the transfer will not kill the origin account.183 * ---------------------------------184 * - Origin account is already in memory, so no DB operations for them.185 * # </weight>186 **/187 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>]>;188 /**189 * Transfer the entire transferable balance from the caller account.190 * 191 * NOTE: This function only attempts to transfer _transferable_ balances. This means that192 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be193 * transferred by this function. To ensure that this function results in a killed account,194 * you might need to prepare the account by removing any reference counters, storage195 * deposits, etc...196 * 197 * The dispatch origin of this call must be Signed.198 * 199 * - `dest`: The recipient of the transfer.200 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all201 * of the funds the account has, causing the sender account to be killed (false), or202 * transfer everything except at least the existential deposit, which will guarantee to203 * keep the sender account alive (true). # <weight>204 * - O(1). Just like transfer, but reading the user's transferable balance first.205 * #</weight>206 **/207 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;208 /**209 * Same as the [`transfer`] call, but with a check that the transfer will not kill the210 * origin account.211 * 212 * 99% of the time you want [`transfer`] instead.213 * 214 * [`transfer`]: struct.Pallet.html#method.transfer215 **/216 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>]>;217 /**218 * Generic tx219 **/220 [key: string]: SubmittableExtrinsicFunction<ApiType>;221 };222 charging: {223 /**224 * Generic tx225 **/226 [key: string]: SubmittableExtrinsicFunction<ApiType>;227 };228 collatorSelection: {229 /**230 * Add a collator to the list of invulnerable (fixed) collators.231 **/232 addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;233 /**234 * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.235 * Note that the collator can only leave on session change.236 * The `LicenseBond` will be unreserved and returned immediately.237 * 238 * This call is, of course, not applicable to `Invulnerable` collators.239 **/240 forceReleaseLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;241 /**242 * Purchase a license on block collation for this account.243 * It does not make it a collator candidate, use `onboard` afterward. The account must244 * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.245 * 246 * This call is not available to `Invulnerable` collators.247 **/248 getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;249 /**250 * Deregister `origin` as a collator candidate. Note that the collator can only leave on251 * session change. The license to `onboard` later at any other time will remain.252 **/253 offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;254 /**255 * Register this account as a candidate for collators for next sessions.256 * The account must already hold a license, and cannot offboard immediately during a session.257 * 258 * This call is not available to `Invulnerable` collators.259 **/260 onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;261 /**262 * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.263 * 264 * This call is not available to `Invulnerable` collators.265 **/266 releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;267 /**268 * Remove a collator from the list of invulnerable (fixed) collators.269 **/270 removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;271 /**272 * Generic tx273 **/274 [key: string]: SubmittableExtrinsicFunction<ApiType>;275 };276 configuration: {277 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;278 setCollatorSelectionDesiredCollators: AugmentedSubmittable<(max: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;279 setCollatorSelectionKickThreshold: AugmentedSubmittable<(threshold: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;280 setCollatorSelectionLicenseBond: AugmentedSubmittable<(amount: Option<u128> | null | Uint8Array | u128 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u128>]>;281 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;282 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;283 setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;284 /**285 * Generic tx286 **/287 [key: string]: SubmittableExtrinsicFunction<ApiType>;288 };289 cumulusXcm: {290 /**291 * Generic tx292 **/293 [key: string]: SubmittableExtrinsicFunction<ApiType>;294 };295 dataManagement: {296 /**297 * Start contract migration, inserts contract stub at target address,298 * and marks account as pending, allowing to insert storage299 **/300 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;301 /**302 * Finish contract migration, allows it to be called.303 * It is not possible to alter contract storage via [`Self::set_data`]304 * after this call.305 **/306 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;307 /**308 * Create ethereum events attached to the fake transaction309 **/310 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;311 /**312 * Create substrate events313 **/314 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;315 /**316 * Insert or remove identities.317 **/318 insertIdentities: AugmentedSubmittable<(identities: Vec<ITuple<[AccountId32, Option<PalletIdentityRegistration>]>> | ([AccountId32 | string | Uint8Array, Option<PalletIdentityRegistration> | null | Uint8Array | PalletIdentityRegistration | { judgements?: any; deposit?: any; info?: any } | string])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[AccountId32, Option<PalletIdentityRegistration>]>>]>;319 /**320 * Insert items into contract storage, this method can be called321 * multiple times322 **/323 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;324 /**325 * Generic tx326 **/327 [key: string]: SubmittableExtrinsicFunction<ApiType>;328 };329 dmpQueue: {330 /**331 * Service a single overweight message.332 * 333 * - `origin`: Must pass `ExecuteOverweightOrigin`.334 * - `index`: The index of the overweight message to service.335 * - `weight_limit`: The amount of weight that message execution may take.336 * 337 * Errors:338 * - `Unknown`: Message of `index` is unknown.339 * - `OverLimit`: Message execution may use greater than `weight_limit`.340 * 341 * Events:342 * - `OverweightServiced`: On success.343 **/344 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;345 /**346 * Generic tx347 **/348 [key: string]: SubmittableExtrinsicFunction<ApiType>;349 };350 ethereum: {351 /**352 * Transact an Ethereum transaction.353 **/354 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;355 /**356 * Generic tx357 **/358 [key: string]: SubmittableExtrinsicFunction<ApiType>;359 };360 evm: {361 /**362 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.363 **/364 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>]>>]>;365 /**366 * Issue an EVM create operation. This is similar to a contract creation transaction in367 * Ethereum.368 **/369 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>]>>]>;370 /**371 * Issue an EVM create2 operation.372 **/373 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>]>>]>;374 /**375 * Withdraw balance from EVM into currency/balances pallet.376 **/377 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;378 /**379 * Generic tx380 **/381 [key: string]: SubmittableExtrinsicFunction<ApiType>;382 };383 foreignAssets: {384 registerForeignAsset: AugmentedSubmittable<(owner: AccountId32 | string | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;385 updateForeignAsset: AugmentedSubmittable<(foreignAssetId: u32 | AnyNumber | Uint8Array, location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, metadata: PalletForeignAssetsModuleAssetMetadata | { name?: any; symbol?: any; decimals?: any; minimalBalance?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, XcmVersionedMultiLocation, PalletForeignAssetsModuleAssetMetadata]>;386 /**387 * Generic tx388 **/389 [key: string]: SubmittableExtrinsicFunction<ApiType>;390 };391 identity: {392 /**393 * Add a registrar to the system.394 * 395 * The dispatch origin for this call must be `T::RegistrarOrigin`.396 * 397 * - `account`: the account of the registrar.398 * 399 * Emits `RegistrarAdded` if successful.400 * 401 * # <weight>402 * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).403 * - One storage mutation (codec `O(R)`).404 * - One event.405 * # </weight>406 **/407 addRegistrar: AugmentedSubmittable<(account: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;408 /**409 * Add the given account to the sender's subs.410 * 411 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated412 * to the sender.413 * 414 * The dispatch origin for this call must be _Signed_ and the sender must have a registered415 * sub identity of `sub`.416 **/417 addSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Data]>;418 /**419 * Cancel a previous request.420 * 421 * Payment: A previously reserved deposit is returned on success.422 * 423 * The dispatch origin for this call must be _Signed_ and the sender must have a424 * registered identity.425 * 426 * - `reg_index`: The index of the registrar whose judgement is no longer requested.427 * 428 * Emits `JudgementUnrequested` if successful.429 * 430 * # <weight>431 * - `O(R + X)`.432 * - One balance-reserve operation.433 * - One storage mutation `O(R + X)`.434 * - One event435 * # </weight>436 **/437 cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;438 /**439 * Clear an account's identity info and all sub-accounts and return all deposits.440 * 441 * Payment: All reserved balances on the account are returned.442 * 443 * The dispatch origin for this call must be _Signed_ and the sender must have a registered444 * identity.445 * 446 * Emits `IdentityCleared` if successful.447 * 448 * # <weight>449 * - `O(R + S + X)`450 * - where `R` registrar-count (governance-bounded).451 * - where `S` subs-count (hard- and deposit-bounded).452 * - where `X` additional-field-count (deposit-bounded and code-bounded).453 * - One balance-unreserve operation.454 * - `2` storage reads and `S + 2` storage deletions.455 * - One event.456 * # </weight>457 **/458 clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;459 /**460 * Remove an account's identity and sub-account information and slash the deposits.461 * 462 * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by463 * `Slash`. Verification request deposits are not returned; they should be cancelled464 * manually using `cancel_request`.465 * 466 * The dispatch origin for this call must match `T::ForceOrigin`.467 * 468 * - `target`: the account whose identity the judgement is upon. This must be an account469 * with a registered identity.470 * 471 * Emits `IdentityKilled` if successful.472 * 473 * # <weight>474 * - `O(R + S + X)`.475 * - One balance-reserve operation.476 * - `S + 2` storage mutations.477 * - One event.478 * # </weight>479 **/480 killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;481 /**482 * Provide a judgement for an account's identity.483 * 484 * The dispatch origin for this call must be _Signed_ and the sender must be the account485 * of the registrar whose index is `reg_index`.486 * 487 * - `reg_index`: the index of the registrar whose judgement is being made.488 * - `target`: the account whose identity the judgement is upon. This must be an account489 * with a registered identity.490 * - `judgement`: the judgement of the registrar of index `reg_index` about `target`.491 * - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.492 * 493 * Emits `JudgementGiven` if successful.494 * 495 * # <weight>496 * - `O(R + X)`.497 * - One balance-transfer operation.498 * - Up to one account-lookup operation.499 * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`.500 * - One event.501 * # </weight>502 **/503 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]>;504 /**505 * Remove the sender as a sub-account.506 * 507 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated508 * to the sender (*not* the original depositor).509 * 510 * The dispatch origin for this call must be _Signed_ and the sender must have a registered511 * super-identity.512 * 513 * NOTE: This should not normally be used, but is provided in the case that the non-514 * controller of an account is maliciously registered as a sub-account.515 **/516 quitSub: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;517 /**518 * Remove the given account from the sender's subs.519 * 520 * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated521 * to the sender.522 * 523 * The dispatch origin for this call must be _Signed_ and the sender must have a registered524 * sub identity of `sub`.525 **/526 removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;527 /**528 * Alter the associated name of the given sub-account.529 * 530 * The dispatch origin for this call must be _Signed_ and the sender must have a registered531 * sub identity of `sub`.532 **/533 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]>;534 /**535 * Request a judgement from a registrar.536 * 537 * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement538 * given.539 * 540 * The dispatch origin for this call must be _Signed_ and the sender must have a541 * registered identity.542 * 543 * - `reg_index`: The index of the registrar whose judgement is requested.544 * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:545 * 546 * ```nocompile547 * Self::registrars().get(reg_index).unwrap().fee548 * ```549 * 550 * Emits `JudgementRequested` if successful.551 * 552 * # <weight>553 * - `O(R + X)`.554 * - One balance-reserve operation.555 * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`.556 * - One event.557 * # </weight>558 **/559 requestJudgement: AugmentedSubmittable<(regIndex: Compact<u32> | AnyNumber | Uint8Array, maxFee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;560 /**561 * Change the account associated with a registrar.562 * 563 * The dispatch origin for this call must be _Signed_ and the sender must be the account564 * of the registrar whose index is `index`.565 * 566 * - `index`: the index of the registrar whose fee is to be set.567 * - `new`: the new account ID.568 * 569 * # <weight>570 * - `O(R)`.571 * - One storage mutation `O(R)`.572 * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis)573 * # </weight>574 **/575 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]>;576 /**577 * Set the fee required for a judgement to be requested from a registrar.578 * 579 * The dispatch origin for this call must be _Signed_ and the sender must be the account580 * of the registrar whose index is `index`.581 * 582 * - `index`: the index of the registrar whose fee is to be set.583 * - `fee`: the new fee.584 * 585 * # <weight>586 * - `O(R)`.587 * - One storage mutation `O(R)`.588 * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis)589 * # </weight>590 **/591 setFee: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fee: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Compact<u128>]>;592 /**593 * Set the field information for a registrar.594 * 595 * The dispatch origin for this call must be _Signed_ and the sender must be the account596 * of the registrar whose index is `index`.597 * 598 * - `index`: the index of the registrar whose fee is to be set.599 * - `fields`: the fields that the registrar concerns themselves with.600 * 601 * # <weight>602 * - `O(R)`.603 * - One storage mutation `O(R)`.604 * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis)605 * # </weight>606 **/607 setFields: AugmentedSubmittable<(index: Compact<u32> | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic<ApiType>, [Compact<u32>, PalletIdentityBitFlags]>;608 /**609 * Set an account's identity information and reserve the appropriate deposit.610 * 611 * If the account already has identity information, the deposit is taken as part payment612 * for the new deposit.613 * 614 * The dispatch origin for this call must be _Signed_.615 * 616 * - `info`: The identity information.617 * 618 * Emits `IdentitySet` if successful.619 * 620 * # <weight>621 * - `O(X + X' + R)`622 * - where `X` additional-field-count (deposit-bounded and code-bounded)623 * - where `R` judgements-count (registrar-count-bounded)624 * - One balance reserve operation.625 * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`).626 * - One event.627 * # </weight>628 **/629 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]>;630 /**631 * Set the sub-accounts of the sender.632 * 633 * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned634 * and an amount `SubAccountDeposit` will be reserved for each item in `subs`.635 * 636 * The dispatch origin for this call must be _Signed_ and the sender must have a registered637 * identity.638 * 639 * - `subs`: The identity's (new) sub-accounts.640 * 641 * # <weight>642 * - `O(P + S)`643 * - where `P` old-subs-count (hard- and deposit-bounded).644 * - where `S` subs-count (hard- and deposit-bounded).645 * - At most one balance operations.646 * - DB:647 * - `P + S` storage mutations (codec complexity `O(1)`)648 * - One storage read (codec complexity `O(P)`).649 * - One storage write (codec complexity `O(S)`).650 * - One storage-exists (`IdentityOf::contains_key`).651 * # </weight>652 **/653 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]>>]>;654 /**655 * Generic tx656 **/657 [key: string]: SubmittableExtrinsicFunction<ApiType>;658 };659 inflation: {660 /**661 * This method sets the inflation start date. Can be only called once.662 * Inflation start block can be backdated and will catch up. The method will create Treasury663 * account if it does not exist and perform the first inflation deposit.664 * 665 * # Permissions666 * 667 * * Root668 * 669 * # Arguments670 * 671 * * inflation_start_relay_block: The relay chain block at which inflation should start672 **/673 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;674 /**675 * Generic tx676 **/677 [key: string]: SubmittableExtrinsicFunction<ApiType>;678 };679 maintenance: {680 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;681 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;682 /**683 * Generic tx684 **/685 [key: string]: SubmittableExtrinsicFunction<ApiType>;686 };687 parachainSystem: {688 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;689 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;690 /**691 * Set the current validation data.692 * 693 * This should be invoked exactly once per block. It will panic at the finalization694 * phase if the call was not invoked.695 * 696 * The dispatch origin for this call must be `Inherent`697 * 698 * As a side effect, this function upgrades the current validation function699 * if the appropriate time has come.700 **/701 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;702 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;703 /**704 * Generic tx705 **/706 [key: string]: SubmittableExtrinsicFunction<ApiType>;707 };708 polkadotXcm: {709 /**710 * Execute an XCM message from a local, signed, origin.711 * 712 * An event is deposited indicating whether `msg` could be executed completely or only713 * partially.714 * 715 * No more than `max_weight` will be used in its attempted execution. If this is less than the716 * maximum amount of weight that the message could take to be executed, then no execution717 * attempt will be made.718 * 719 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully720 * to completion; only that *some* of it was executed.721 **/722 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;723 /**724 * Set a safe XCM version (the version that XCM should be encoded with if the most recent725 * version a destination can accept is unknown).726 * 727 * - `origin`: Must be Root.728 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.729 **/730 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;731 /**732 * Ask a location to notify us regarding their XCM version and any changes to it.733 * 734 * - `origin`: Must be Root.735 * - `location`: The location to which we should subscribe for XCM version notifications.736 **/737 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;738 /**739 * Require that a particular destination should no longer notify us regarding any XCM740 * version changes.741 * 742 * - `origin`: Must be Root.743 * - `location`: The location to which we are currently subscribed for XCM version744 * notifications which we no longer desire.745 **/746 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;747 /**748 * Extoll that a particular destination can be communicated with through a particular749 * version of XCM.750 * 751 * - `origin`: Must be Root.752 * - `location`: The destination that is being described.753 * - `xcm_version`: The latest version of XCM that `location` supports.754 **/755 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;756 /**757 * Transfer some assets from the local chain to the sovereign account of a destination758 * chain and forward a notification XCM.759 * 760 * Fee payment on the destination side is made from the asset in the `assets` vector of761 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight762 * is needed than `weight_limit`, then the operation will fail and the assets send may be763 * at risk.764 * 765 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.766 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send767 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.768 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be769 * an `AccountId32` value.770 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the771 * `dest` side.772 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay773 * fees.774 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.775 **/776 limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>;777 /**778 * Teleport some assets from the local chain to some destination chain.779 * 780 * Fee payment on the destination side is made from the asset in the `assets` vector of781 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight782 * is needed than `weight_limit`, then the operation will fail and the assets send may be783 * at risk.784 * 785 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.786 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send787 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.788 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be789 * an `AccountId32` value.790 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the791 * `dest` side. May not be empty.792 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay793 * fees.794 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.795 **/796 limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>;797 /**798 * Transfer some assets from the local chain to the sovereign account of a destination799 * chain and forward a notification XCM.800 * 801 * Fee payment on the destination side is made from the asset in the `assets` vector of802 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,803 * with all fees taken as needed from the asset.804 * 805 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.806 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send807 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.808 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be809 * an `AccountId32` value.810 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the811 * `dest` side.812 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay813 * fees.814 **/815 reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;816 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;817 /**818 * Teleport some assets from the local chain to some destination chain.819 * 820 * Fee payment on the destination side is made from the asset in the `assets` vector of821 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,822 * with all fees taken as needed from the asset.823 * 824 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.825 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send826 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.827 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be828 * an `AccountId32` value.829 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the830 * `dest` side. May not be empty.831 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay832 * fees.833 **/834 teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>;835 /**836 * Generic tx837 **/838 [key: string]: SubmittableExtrinsicFunction<ApiType>;839 };840 rmrkCore: {841 /**842 * Accept an NFT sent from another account to self or an owned NFT.843 * 844 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.845 * 846 * # Permissions:847 * - Token-owner-to-be848 * 849 * # Arguments:850 * - `origin`: sender of the transaction851 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.852 * - `rmrk_nft_id`: ID of the NFT to be accepted.853 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,854 * whichever the accepted NFT was sent to.855 **/856 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;857 /**858 * Accept the addition of a newly created pending resource to an existing NFT.859 * 860 * This transaction is needed when a resource is created and assigned to an NFT861 * by a non-owner, i.e. the collection issuer, with one of the862 * [`add_...` transactions](Pallet::add_basic_resource).863 * 864 * # Permissions:865 * - Token owner866 * 867 * # Arguments:868 * - `origin`: sender of the transaction869 * - `rmrk_collection_id`: RMRK collection ID of the NFT.870 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.871 * - `resource_id`: ID of the newly created pending resource.872 * accept the addition of a new resource to an existing NFT873 **/874 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;875 /**876 * Accept the removal of a removal-pending resource from an NFT.877 * 878 * This transaction is needed when a non-owner, i.e. the collection issuer,879 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.880 * 881 * # Permissions:882 * - Token owner883 * 884 * # Arguments:885 * - `origin`: sender of the transaction886 * - `rmrk_collection_id`: RMRK collection ID of the NFT.887 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.888 * - `resource_id`: ID of the removal-pending resource.889 **/890 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;891 /**892 * Create and set/propose a basic resource for an NFT.893 * 894 * A basic resource is the simplest, lacking a Base and anything that comes with it.895 * See RMRK docs for more information and examples.896 * 897 * # Permissions:898 * - Collection issuer - if not the token owner, adding the resource will warrant899 * the owner's [acceptance](Pallet::accept_resource).900 * 901 * # Arguments:902 * - `origin`: sender of the transaction903 * - `rmrk_collection_id`: RMRK collection ID of the NFT.904 * - `nft_id`: ID of the NFT to assign a resource to.905 * - `resource`: Data of the resource to be created.906 **/907 addBasicResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceBasicResource | { src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceBasicResource]>;908 /**909 * Create and set/propose a composable resource for an NFT.910 * 911 * A composable resource links to a Base and has a subset of its Parts it is composed of.912 * See RMRK docs for more information and examples.913 * 914 * # Permissions:915 * - Collection issuer - if not the token owner, adding the resource will warrant916 * the owner's [acceptance](Pallet::accept_resource).917 * 918 * # Arguments:919 * - `origin`: sender of the transaction920 * - `rmrk_collection_id`: RMRK collection ID of the NFT.921 * - `nft_id`: ID of the NFT to assign a resource to.922 * - `resource`: Data of the resource to be created.923 **/924 addComposableResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceComposableResource | { parts?: any; base?: any; src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceComposableResource]>;925 /**926 * Create and set/propose a slot resource for an NFT.927 * 928 * A slot resource links to a Base and a slot ID in it which it can fit into.929 * See RMRK docs for more information and examples.930 * 931 * # Permissions:932 * - Collection issuer - if not the token owner, adding the resource will warrant933 * the owner's [acceptance](Pallet::accept_resource).934 * 935 * # Arguments:936 * - `origin`: sender of the transaction937 * - `rmrk_collection_id`: RMRK collection ID of the NFT.938 * - `nft_id`: ID of the NFT to assign a resource to.939 * - `resource`: Data of the resource to be created.940 **/941 addSlotResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceSlotResource | { base?: any; src?: any; metadata?: any; slot?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsResourceSlotResource]>;942 /**943 * Burn an NFT, destroying it and its nested tokens up to the specified limit.944 * If the burning budget is exceeded, the transaction is reverted.945 * 946 * This is the way to burn a nested token as well.947 * 948 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).949 * 950 * # Permissions:951 * * Token owner952 * 953 * # Arguments:954 * - `origin`: sender of the transaction955 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.956 * - `nft_id`: ID of the NFT to be destroyed.957 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction958 * is reverted if there are more tokens to burn in the nesting tree than this number.959 * This is primarily a mechanism of transaction weight control.960 **/961 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;962 /**963 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).964 * 965 * # Permissions:966 * * Collection issuer967 * 968 * # Arguments:969 * - `origin`: sender of the transaction970 * - `collection_id`: RMRK collection ID to change the issuer of.971 * - `new_issuer`: Collection's new issuer.972 **/973 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;974 /**975 * Create a new collection of NFTs.976 * 977 * # Permissions:978 * * Anyone - will be assigned as the issuer of the collection.979 * 980 * # Arguments:981 * - `origin`: sender of the transaction982 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.983 * - `max`: Optional maximum number of tokens.984 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.985 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.986 **/987 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;988 /**989 * Destroy a collection.990 * 991 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.992 * 993 * # Permissions:994 * * Collection issuer995 * 996 * # Arguments:997 * - `origin`: sender of the transaction998 * - `collection_id`: RMRK ID of the collection to destroy.999 **/1000 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1001 /**1002 * "Lock" the collection and prevent new token creation. Cannot be undone.1003 * 1004 * # Permissions:1005 * * Collection issuer1006 * 1007 * # Arguments:1008 * - `origin`: sender of the transaction1009 * - `collection_id`: RMRK ID of the collection to lock.1010 **/1011 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1012 /**1013 * Mint an NFT in a specified collection.1014 * 1015 * # Permissions:1016 * * Collection issuer1017 * 1018 * # Arguments:1019 * - `origin`: sender of the transaction1020 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).1021 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.1022 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.1023 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.1024 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.1025 * - `transferable`: Can this NFT be transferred? Cannot be changed.1026 * - `resources`: Resource data to be added to the NFT immediately after minting.1027 **/1028 mintNft: AugmentedSubmittable<(owner: Option<AccountId32> | null | Uint8Array | AccountId32 | string, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option<AccountId32> | null | Uint8Array | AccountId32 | string, royaltyAmount: Option<Permill> | null | Uint8Array | Permill | AnyNumber, metadata: Bytes | string | Uint8Array, transferable: bool | boolean | Uint8Array, resources: Option<Vec<RmrkTraitsResourceResourceTypes>> | null | Uint8Array | Vec<RmrkTraitsResourceResourceTypes> | (RmrkTraitsResourceResourceTypes | { Basic: any } | { Composable: any } | { Slot: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<AccountId32>, u32, Option<AccountId32>, Option<Permill>, Bytes, bool, Option<Vec<RmrkTraitsResourceResourceTypes>>]>;1029 /**1030 * Reject an NFT sent from another account to self or owned NFT.1031 * The NFT in question will not be sent back and burnt instead.1032 * 1033 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.1034 * 1035 * # Permissions:1036 * - Token-owner-to-be-not1037 * 1038 * # Arguments:1039 * - `origin`: sender of the transaction1040 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.1041 * - `rmrk_nft_id`: ID of the NFT to be rejected.1042 **/1043 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1044 /**1045 * Remove and erase a resource from an NFT.1046 * 1047 * If the sender does not own the NFT, then it will be pending confirmation,1048 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.1049 * 1050 * # Permissions1051 * - Collection issuer1052 * 1053 * # Arguments1054 * - `origin`: sender of the transaction1055 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.1056 * - `nft_id`: ID of the NFT with a resource to be removed.1057 * - `resource_id`: ID of the resource to be removed.1058 **/1059 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;1060 /**1061 * Transfer an NFT from an account/NFT A to another account/NFT B.1062 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].1063 * 1064 * If the target owner is an NFT owned by another account, then the NFT will enter1065 * the pending state and will have to be accepted by the other account.1066 * 1067 * # Permissions:1068 * - Token owner1069 * 1070 * # Arguments:1071 * - `origin`: sender of the transaction1072 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.1073 * - `rmrk_nft_id`: ID of the NFT to be transferred.1074 * - `new_owner`: New owner of the nft which can be either an account or a NFT.1075 **/1076 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;1077 /**1078 * Set a different order of resource priorities for an NFT. Priorities can be used,1079 * for example, for order of rendering.1080 * 1081 * Note that the priorities are not updated automatically, and are an empty vector1082 * by default. There is no pre-set definition for the order to be particular,1083 * it can be interpreted arbitrarily use-case by use-case.1084 * 1085 * # Permissions:1086 * - Token owner1087 * 1088 * # Arguments:1089 * - `origin`: sender of the transaction1090 * - `rmrk_collection_id`: RMRK collection ID of the NFT.1091 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.1092 * - `priorities`: Ordered vector of resource IDs.1093 **/1094 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;1095 /**1096 * Add or edit a custom user property, a key-value pair, describing the metadata1097 * of a token or a collection, on either one of these.1098 * 1099 * Note that in this proxy implementation many details regarding RMRK are stored1100 * as scoped properties prefixed with "rmrk:", normally inaccessible1101 * to external transactions and RPCs.1102 * 1103 * # Permissions:1104 * - Collection issuer - in case of collection property1105 * - Token owner - in case of NFT property1106 * 1107 * # Arguments:1108 * - `origin`: sender of the transaction1109 * - `rmrk_collection_id`: RMRK collection ID.1110 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.1111 * - `key`: Key of the custom property to be referenced by.1112 * - `value`: Value of the custom property to be stored.1113 **/1114 setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact<u32> | AnyNumber | Uint8Array, maybeNftId: Option<u32> | null | Uint8Array | u32 | AnyNumber, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>, Option<u32>, Bytes, Bytes]>;1115 /**1116 * Generic tx1117 **/1118 [key: string]: SubmittableExtrinsicFunction<ApiType>;1119 };1120 rmrkEquip: {1121 /**1122 * Create a new Base.1123 * 1124 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)1125 * 1126 * # Permissions1127 * - Anyone - will be assigned as the issuer of the Base.1128 * 1129 * # Arguments:1130 * - `origin`: Caller, will be assigned as the issuer of the Base1131 * - `base_type`: Arbitrary media type, e.g. "svg".1132 * - `symbol`: Arbitrary client-chosen symbol.1133 * - `parts`: Array of Fixed and Slot Parts composing the Base,1134 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).1135 **/1136 createBase: AugmentedSubmittable<(baseType: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, parts: Vec<RmrkTraitsPartPartType> | (RmrkTraitsPartPartType | { FixedPart: any } | { SlotPart: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Bytes, Bytes, Vec<RmrkTraitsPartPartType>]>;1137 /**1138 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.1139 * 1140 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).1141 * 1142 * # Permissions:1143 * - Base issuer1144 * 1145 * # Arguments:1146 * - `origin`: sender of the transaction1147 * - `base_id`: Base containing the Slot Part to be updated.1148 * - `slot_id`: Slot Part whose Equippable List is being updated .1149 * - `equippables`: List of equippables that will override the current Equippables list.1150 **/1151 equippable: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, slotId: u32 | AnyNumber | Uint8Array, equippables: RmrkTraitsPartEquippableList | { All: any } | { Empty: any } | { Custom: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsPartEquippableList]>;1152 /**1153 * Add a Theme to a Base.1154 * A Theme named "default" is required prior to adding other Themes.1155 * 1156 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).1157 * 1158 * # Permissions:1159 * - Base issuer1160 * 1161 * # Arguments:1162 * - `origin`: sender of the transaction1163 * - `base_id`: Base ID containing the Theme to be updated.1164 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an1165 * array of [key, value, inherit].1166 * - `key`: Arbitrary BoundedString, defined by client.1167 * - `value`: Arbitrary BoundedString, defined by client.1168 * - `inherit`: Optional bool.1169 **/1170 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;1171 /**1172 * Generic tx1173 **/1174 [key: string]: SubmittableExtrinsicFunction<ApiType>;1175 };1176 session: {1177 /**1178 * Removes any session key(s) of the function caller.1179 * 1180 * This doesn't take effect until the next session.1181 * 1182 * The dispatch origin of this function must be Signed and the account must be either be1183 * convertible to a validator ID using the chain's typical addressing system (this usually1184 * means being a controller account) or directly convertible into a validator ID (which1185 * usually means being a stash account).1186 * 1187 * # <weight>1188 * - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length1189 * of `T::Keys::key_ids()` which is fixed.1190 * - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`1191 * - DbWrites: `NextKeys`, `origin account`1192 * - DbWrites per key id: `KeyOwner`1193 * # </weight>1194 **/1195 purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1196 /**1197 * Sets the session key(s) of the function caller to `keys`.1198 * Allows an account to set its session key prior to becoming a validator.1199 * This doesn't take effect until the next session.1200 * 1201 * The dispatch origin of this function must be signed.1202 * 1203 * # <weight>1204 * - Complexity: `O(1)`. Actual cost depends on the number of length of1205 * `T::Keys::key_ids()` which is fixed.1206 * - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`1207 * - DbWrites: `origin account`, `NextKeys`1208 * - DbReads per key id: `KeyOwner`1209 * - DbWrites per key id: `KeyOwner`1210 * # </weight>1211 **/1212 setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;1213 /**1214 * Generic tx1215 **/1216 [key: string]: SubmittableExtrinsicFunction<ApiType>;1217 };1218 structure: {1219 /**1220 * Generic tx1221 **/1222 [key: string]: SubmittableExtrinsicFunction<ApiType>;1223 };1224 sudo: {1225 /**1226 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo1227 * key.1228 * 1229 * The dispatch origin for this call must be _Signed_.1230 * 1231 * # <weight>1232 * - O(1).1233 * - Limited storage reads.1234 * - One DB change.1235 * # </weight>1236 **/1237 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1238 /**1239 * Authenticates the sudo key and dispatches a function call with `Root` origin.1240 * 1241 * The dispatch origin for this call must be _Signed_.1242 * 1243 * # <weight>1244 * - O(1).1245 * - Limited storage reads.1246 * - One DB write (event).1247 * - Weight of derivative `call` execution + 10,000.1248 * # </weight>1249 **/1250 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;1251 /**1252 * Authenticates the sudo key and dispatches a function call with `Signed` origin from1253 * a given account.1254 * 1255 * The dispatch origin for this call must be _Signed_.1256 * 1257 * # <weight>1258 * - O(1).1259 * - Limited storage reads.1260 * - One DB write (event).1261 * - Weight of derivative `call` execution + 10,000.1262 * # </weight>1263 **/1264 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]>;1265 /**1266 * Authenticates the sudo key and dispatches a function call with `Root` origin.1267 * This function does not check the weight of the call, and instead allows the1268 * Sudo user to specify the weight of the call.1269 * 1270 * The dispatch origin for this call must be _Signed_.1271 * 1272 * # <weight>1273 * - O(1).1274 * - The weight of this call is defined by the caller.1275 * # </weight>1276 **/1277 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;1278 /**1279 * Generic tx1280 **/1281 [key: string]: SubmittableExtrinsicFunction<ApiType>;1282 };1283 system: {1284 /**1285 * Kill all storage items with a key that starts with the given prefix.1286 * 1287 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1288 * the prefix we are removing to accurately calculate the weight of this function.1289 **/1290 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1291 /**1292 * Kill some items from storage.1293 **/1294 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1295 /**1296 * Make some on-chain remark.1297 * 1298 * # <weight>1299 * - `O(1)`1300 * # </weight>1301 **/1302 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1303 /**1304 * Make some on-chain remark and emit event.1305 **/1306 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1307 /**1308 * Set the new runtime code.1309 * 1310 * # <weight>1311 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`1312 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is1313 * expensive).1314 * - 1 storage write (codec `O(C)`).1315 * - 1 digest item.1316 * - 1 event.1317 * The weight of this function is dependent on the runtime, but generally this is very1318 * expensive. We will treat this as a full block.1319 * # </weight>1320 **/1321 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1322 /**1323 * Set the new runtime code without doing any checks of the given `code`.1324 * 1325 * # <weight>1326 * - `O(C)` where `C` length of `code`1327 * - 1 storage write (codec `O(C)`).1328 * - 1 digest item.1329 * - 1 event.1330 * The weight of this function is dependent on the runtime. We will treat this as a full1331 * block. # </weight>1332 **/1333 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1334 /**1335 * Set the number of pages in the WebAssembly environment's heap.1336 **/1337 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1338 /**1339 * Set some items of storage.1340 **/1341 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1342 /**1343 * Generic tx1344 **/1345 [key: string]: SubmittableExtrinsicFunction<ApiType>;1346 };1347 testUtils: {1348 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1349 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1350 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1351 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1352 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1353 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1354 /**1355 * Generic tx1356 **/1357 [key: string]: SubmittableExtrinsicFunction<ApiType>;1358 };1359 timestamp: {1360 /**1361 * Set the current time.1362 * 1363 * This call should be invoked exactly once per block. It will panic at the finalization1364 * phase, if this call hasn't been invoked by that time.1365 * 1366 * The timestamp should be greater than the previous one by the amount specified by1367 * `MinimumPeriod`.1368 * 1369 * The dispatch origin for this call must be `Inherent`.1370 * 1371 * # <weight>1372 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1373 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1374 * `on_finalize`)1375 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1376 * # </weight>1377 **/1378 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1379 /**1380 * Generic tx1381 **/1382 [key: string]: SubmittableExtrinsicFunction<ApiType>;1383 };1384 tokens: {1385 /**1386 * Exactly as `transfer`, except the origin must be root and the source1387 * account may be specified.1388 * 1389 * The dispatch origin for this call must be _Root_.1390 * 1391 * - `source`: The sender of the transfer.1392 * - `dest`: The recipient of the transfer.1393 * - `currency_id`: currency type.1394 * - `amount`: free balance amount to tranfer.1395 **/1396 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>]>;1397 /**1398 * Set the balances of a given account.1399 * 1400 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1401 * will also decrease the total issuance of the system1402 * (`TotalIssuance`). If the new free or reserved balance is below the1403 * existential deposit, it will reap the `AccountInfo`.1404 * 1405 * The dispatch origin for this call is `root`.1406 **/1407 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>]>;1408 /**1409 * Transfer some liquid free balance to another account.1410 * 1411 * `transfer` will set the `FreeBalance` of the sender and receiver.1412 * It will decrease the total issuance of the system by the1413 * `TransferFee`. If the sender's account is below the existential1414 * deposit as a result of the transfer, the account will be reaped.1415 * 1416 * The dispatch origin for this call must be `Signed` by the1417 * transactor.1418 * 1419 * - `dest`: The recipient of the transfer.1420 * - `currency_id`: currency type.1421 * - `amount`: free balance amount to tranfer.1422 **/1423 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>]>;1424 /**1425 * Transfer all remaining balance to the given account.1426 * 1427 * NOTE: This function only attempts to transfer _transferable_1428 * balances. This means that any locked, reserved, or existential1429 * deposits (when `keep_alive` is `true`), will not be transferred by1430 * this function. To ensure that this function results in a killed1431 * account, you might need to prepare the account by removing any1432 * reference counters, storage deposits, etc...1433 * 1434 * The dispatch origin for this call must be `Signed` by the1435 * transactor.1436 * 1437 * - `dest`: The recipient of the transfer.1438 * - `currency_id`: currency type.1439 * - `keep_alive`: A boolean to determine if the `transfer_all`1440 * operation should send all of the funds the account has, causing1441 * the sender account to be killed (false), or transfer everything1442 * except at least the existential deposit, which will guarantee to1443 * keep the sender account alive (true).1444 **/1445 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]>;1446 /**1447 * Same as the [`transfer`] call, but with a check that the transfer1448 * will not kill the origin account.1449 * 1450 * 99% of the time you want [`transfer`] instead.1451 * 1452 * The dispatch origin for this call must be `Signed` by the1453 * transactor.1454 * 1455 * - `dest`: The recipient of the transfer.1456 * - `currency_id`: currency type.1457 * - `amount`: free balance amount to tranfer.1458 **/1459 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>]>;1460 /**1461 * Generic tx1462 **/1463 [key: string]: SubmittableExtrinsicFunction<ApiType>;1464 };1465 treasury: {1466 /**1467 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1468 * and the original deposit will be returned.1469 * 1470 * May only be called from `T::ApproveOrigin`.1471 * 1472 * # <weight>1473 * - Complexity: O(1).1474 * - DbReads: `Proposals`, `Approvals`1475 * - DbWrite: `Approvals`1476 * # </weight>1477 **/1478 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1479 /**1480 * Put forward a suggestion for spending. A deposit proportional to the value1481 * is reserved and slashed if the proposal is rejected. It is returned once the1482 * proposal is awarded.1483 * 1484 * # <weight>1485 * - Complexity: O(1)1486 * - DbReads: `ProposalCount`, `origin account`1487 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1488 * # </weight>1489 **/1490 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]>;1491 /**1492 * Reject a proposed spend. The original deposit will be slashed.1493 * 1494 * May only be called from `T::RejectOrigin`.1495 * 1496 * # <weight>1497 * - Complexity: O(1)1498 * - DbReads: `Proposals`, `rejected proposer account`1499 * - DbWrites: `Proposals`, `rejected proposer account`1500 * # </weight>1501 **/1502 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1503 /**1504 * Force a previously approved proposal to be removed from the approval queue.1505 * The original deposit will no longer be returned.1506 * 1507 * May only be called from `T::RejectOrigin`.1508 * - `proposal_id`: The index of a proposal1509 * 1510 * # <weight>1511 * - Complexity: O(A) where `A` is the number of approvals1512 * - Db reads and writes: `Approvals`1513 * # </weight>1514 * 1515 * Errors:1516 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1517 * i.e., the proposal has not been approved. This could also mean the proposal does not1518 * exist altogether, thus there is no way it would have been approved in the first place.1519 **/1520 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1521 /**1522 * Propose and approve a spend of treasury funds.1523 * 1524 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1525 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1526 * - `beneficiary`: The destination account for the transfer.1527 * 1528 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1529 * beneficiary.1530 **/1531 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]>;1532 /**1533 * Generic tx1534 **/1535 [key: string]: SubmittableExtrinsicFunction<ApiType>;1536 };1537 unique: {1538 /**1539 * Add an admin to a collection.1540 * 1541 * NFT Collection can be controlled by multiple admin addresses1542 * (some which can also be servers, for example). Admins can issue1543 * and burn NFTs, as well as add and remove other admins,1544 * but cannot change NFT or Collection ownership.1545 * 1546 * # Permissions1547 * 1548 * * Collection owner1549 * * Collection admin1550 * 1551 * # Arguments1552 * 1553 * * `collection_id`: ID of the Collection to add an admin for.1554 * * `new_admin`: Address of new admin to add.1555 **/1556 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1557 /**1558 * Add an address to allow list.1559 * 1560 * # Permissions1561 * 1562 * * Collection owner1563 * * Collection admin1564 * 1565 * # Arguments1566 * 1567 * * `collection_id`: ID of the modified collection.1568 * * `address`: ID of the address to be added to the allowlist.1569 **/1570 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1571 /**1572 * Allow a non-permissioned address to transfer or burn an item.1573 * 1574 * # Permissions1575 * 1576 * * Collection owner1577 * * Collection admin1578 * * Current item owner1579 * 1580 * # Arguments1581 * 1582 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1583 * * `collection_id`: ID of the collection the item belongs to.1584 * * `item_id`: ID of the item transactions on which are now approved.1585 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1586 * Set to 0 to revoke the approval.1587 **/1588 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]>;1589 /**1590 * Destroy a token on behalf of the owner as a non-owner account.1591 * 1592 * See also: [`approve`][`Pallet::approve`].1593 * 1594 * After this method executes, one approval is removed from the total so that1595 * the approved address will not be able to transfer this item again from this owner.1596 * 1597 * # Permissions1598 * 1599 * * Collection owner1600 * * Collection admin1601 * * Current token owner1602 * * Address approved by current item owner1603 * 1604 * # Arguments1605 * 1606 * * `from`: The owner of the burning item.1607 * * `collection_id`: ID of the collection to which the item belongs.1608 * * `item_id`: ID of item to burn.1609 * * `value`: Number of pieces to burn.1610 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1611 * * Fungible Mode: The desired number of pieces to burn.1612 * * Re-Fungible Mode: The desired number of pieces to burn.1613 **/1614 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]>;1615 /**1616 * Destroy an item.1617 * 1618 * # Permissions1619 * 1620 * * Collection owner1621 * * Collection admin1622 * * Current item owner1623 * 1624 * # Arguments1625 * 1626 * * `collection_id`: ID of the collection to which the item belongs.1627 * * `item_id`: ID of item to burn.1628 * * `value`: Number of pieces of the item to destroy.1629 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1630 * * Fungible Mode: The desired number of pieces to burn.1631 * * Re-Fungible Mode: The desired number of pieces to burn.1632 **/1633 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1634 /**1635 * Change the owner of the collection.1636 * 1637 * # Permissions1638 * 1639 * * Collection owner1640 * 1641 * # Arguments1642 * 1643 * * `collection_id`: ID of the modified collection.1644 * * `new_owner`: ID of the account that will become the owner.1645 **/1646 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1647 /**1648 * Confirm own sponsorship of a collection, becoming the sponsor.1649 * 1650 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1651 * Sponsor can pay the fees of a transaction instead of the sender,1652 * but only within specified limits.1653 * 1654 * # Permissions1655 * 1656 * * Sponsor-to-be1657 * 1658 * # Arguments1659 * 1660 * * `collection_id`: ID of the collection with the pending sponsor.1661 **/1662 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1663 /**1664 * Create a collection of tokens.1665 * 1666 * Each Token may have multiple properties encoded as an array of bytes1667 * of certain length. The initial owner of the collection is set1668 * to the address that signed the transaction and can be changed later.1669 * 1670 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1671 * 1672 * # Permissions1673 * 1674 * * Anyone - becomes the owner of the new collection.1675 * 1676 * # Arguments1677 * 1678 * * `collection_name`: Wide-character string with collection name1679 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1680 * * `collection_description`: Wide-character string with collection description1681 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1682 * * `token_prefix`: Byte string containing the token prefix to mark a collection1683 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1684 * * `mode`: Type of items stored in the collection and type dependent data.1685 **/1686 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]>;1687 /**1688 * Create a collection with explicit parameters.1689 * 1690 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1691 * 1692 * # Permissions1693 * 1694 * * Anyone - becomes the owner of the new collection.1695 * 1696 * # Arguments1697 * 1698 * * `data`: Explicit data of a collection used for its creation.1699 **/1700 createCollectionEx: AugmentedSubmittable<(data: UpDataStructsCreateCollectionData | { mode?: any; access?: any; name?: any; description?: any; tokenPrefix?: any; pendingSponsor?: any; limits?: any; permissions?: any; tokenPropertyPermissions?: any; properties?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [UpDataStructsCreateCollectionData]>;1701 /**1702 * Mint an item within a collection.1703 * 1704 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1705 * 1706 * # Permissions1707 * 1708 * * Collection owner1709 * * Collection admin1710 * * Anyone if1711 * * Allow List is enabled, and1712 * * Address is added to allow list, and1713 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1714 * 1715 * # Arguments1716 * 1717 * * `collection_id`: ID of the collection to which an item would belong.1718 * * `owner`: Address of the initial owner of the item.1719 * * `data`: Token data describing the item to store on chain.1720 **/1721 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]>;1722 /**1723 * Create multiple items within a collection.1724 * 1725 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1726 * 1727 * # Permissions1728 * 1729 * * Collection owner1730 * * Collection admin1731 * * Anyone if1732 * * Allow List is enabled, and1733 * * Address is added to the allow list, and1734 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1735 * 1736 * # Arguments1737 * 1738 * * `collection_id`: ID of the collection to which the tokens would belong.1739 * * `owner`: Address of the initial owner of the tokens.1740 * * `items_data`: Vector of data describing each item to be created.1741 **/1742 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>]>;1743 /**1744 * Create multiple items within a collection with explicitly specified initial parameters.1745 * 1746 * # Permissions1747 * 1748 * * Collection owner1749 * * Collection admin1750 * * Anyone if1751 * * Allow List is enabled, and1752 * * Address is added to allow list, and1753 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1754 * 1755 * # Arguments1756 * 1757 * * `collection_id`: ID of the collection to which the tokens would belong.1758 * * `data`: Explicit item creation data.1759 **/1760 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1761 /**1762 * Delete specified collection properties.1763 * 1764 * # Permissions1765 * 1766 * * Collection Owner1767 * * Collection Admin1768 * 1769 * # Arguments1770 * 1771 * * `collection_id`: ID of the modified collection.1772 * * `property_keys`: Vector of keys of the properties to be deleted.1773 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1774 **/1775 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1776 /**1777 * Delete specified token properties. Currently properties only work with NFTs.1778 * 1779 * # Permissions1780 * 1781 * * Depends on collection's token property permissions and specified property mutability:1782 * * Collection owner1783 * * Collection admin1784 * * Token owner1785 * 1786 * # Arguments1787 * 1788 * * `collection_id`: ID of the collection to which the token belongs.1789 * * `token_id`: ID of the modified token.1790 * * `property_keys`: Vector of keys of the properties to be deleted.1791 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1792 **/1793 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1794 /**1795 * Destroy a collection if no tokens exist within.1796 * 1797 * # Permissions1798 * 1799 * * Collection owner1800 * 1801 * # Arguments1802 * 1803 * * `collection_id`: Collection to destroy.1804 **/1805 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1806 /**1807 * Repairs a collection if the data was somehow corrupted.1808 * 1809 * # Arguments1810 * 1811 * * `collection_id`: ID of the collection to repair.1812 **/1813 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1814 /**1815 * Repairs a token if the data was somehow corrupted.1816 * 1817 * # Arguments1818 * 1819 * * `collection_id`: ID of the collection the item belongs to.1820 * * `item_id`: ID of the item.1821 **/1822 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1823 /**1824 * Remove admin of a collection.1825 * 1826 * An admin address can remove itself. List of admins may become empty,1827 * in which case only Collection Owner will be able to add an Admin.1828 * 1829 * # Permissions1830 * 1831 * * Collection owner1832 * * Collection admin1833 * 1834 * # Arguments1835 * 1836 * * `collection_id`: ID of the collection to remove the admin for.1837 * * `account_id`: Address of the admin to remove.1838 **/1839 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1840 /**1841 * Remove a collection's a sponsor, making everyone pay for their own transactions.1842 * 1843 * # Permissions1844 * 1845 * * Collection owner1846 * 1847 * # Arguments1848 * 1849 * * `collection_id`: ID of the collection with the sponsor to remove.1850 **/1851 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1852 /**1853 * Remove an address from allow list.1854 * 1855 * # Permissions1856 * 1857 * * Collection owner1858 * * Collection admin1859 * 1860 * # Arguments1861 * 1862 * * `collection_id`: ID of the modified collection.1863 * * `address`: ID of the address to be removed from the allowlist.1864 **/1865 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1866 /**1867 * Re-partition a refungible token, while owning all of its parts/pieces.1868 * 1869 * # Permissions1870 * 1871 * * Token owner (must own every part)1872 * 1873 * # Arguments1874 * 1875 * * `collection_id`: ID of the collection the RFT belongs to.1876 * * `token_id`: ID of the RFT.1877 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1878 **/1879 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1880 /**1881 * Sets or unsets the approval of a given operator.1882 * 1883 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1884 * 1885 * # Arguments1886 * 1887 * * `owner`: Token owner1888 * * `operator`: Operator1889 * * `approve`: Should operator status be granted or revoked?1890 **/1891 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1892 /**1893 * Set specific limits of a collection. Empty, or None fields mean chain default.1894 * 1895 * # Permissions1896 * 1897 * * Collection owner1898 * * Collection admin1899 * 1900 * # Arguments1901 * 1902 * * `collection_id`: ID of the modified collection.1903 * * `new_limit`: New limits of the collection. Fields that are not set (None)1904 * will not overwrite the old ones.1905 **/1906 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]>;1907 /**1908 * Set specific permissions of a collection. Empty, or None fields mean chain default.1909 * 1910 * # Permissions1911 * 1912 * * Collection owner1913 * * Collection admin1914 * 1915 * # Arguments1916 * 1917 * * `collection_id`: ID of the modified collection.1918 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1919 * will not overwrite the old ones.1920 **/1921 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1922 /**1923 * Add or change collection properties.1924 * 1925 * # Permissions1926 * 1927 * * Collection owner1928 * * Collection admin1929 * 1930 * # Arguments1931 * 1932 * * `collection_id`: ID of the modified collection.1933 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1934 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1935 **/1936 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1937 /**1938 * Set (invite) a new collection sponsor.1939 * 1940 * If successful, confirmation from the sponsor-to-be will be pending.1941 * 1942 * # Permissions1943 * 1944 * * Collection owner1945 * * Collection admin1946 * 1947 * # Arguments1948 * 1949 * * `collection_id`: ID of the modified collection.1950 * * `new_sponsor`: ID of the account of the sponsor-to-be.1951 **/1952 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1953 /**1954 * Add or change token properties according to collection's permissions.1955 * Currently properties only work with NFTs.1956 * 1957 * # Permissions1958 * 1959 * * Depends on collection's token property permissions and specified property mutability:1960 * * Collection owner1961 * * Collection admin1962 * * Token owner1963 * 1964 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1965 * 1966 * # Arguments1967 * 1968 * * `collection_id: ID of the collection to which the token belongs.1969 * * `token_id`: ID of the modified token.1970 * * `properties`: Vector of key-value pairs stored as the token's metadata.1971 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1972 **/1973 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>]>;1974 /**1975 * Add or change token property permissions of a collection.1976 * 1977 * Without a permission for a particular key, a property with that key1978 * cannot be created in a token.1979 * 1980 * # Permissions1981 * 1982 * * Collection owner1983 * * Collection admin1984 * 1985 * # Arguments1986 * 1987 * * `collection_id`: ID of the modified collection.1988 * * `property_permissions`: Vector of permissions for property keys.1989 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1990 **/1991 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1992 /**1993 * Completely allow or disallow transfers for a particular collection.1994 * 1995 * # Permissions1996 * 1997 * * Collection owner1998 * 1999 * # Arguments2000 * 2001 * * `collection_id`: ID of the collection.2002 * * `value`: New value of the flag, are transfers allowed?2003 **/2004 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;2005 /**2006 * Change ownership of the token.2007 * 2008 * # Permissions2009 * 2010 * * Collection owner2011 * * Collection admin2012 * * Current token owner2013 * 2014 * # Arguments2015 * 2016 * * `recipient`: Address of token recipient.2017 * * `collection_id`: ID of the collection the item belongs to.2018 * * `item_id`: ID of the item.2019 * * Non-Fungible Mode: Required.2020 * * Fungible Mode: Ignored.2021 * * Re-Fungible Mode: Required.2022 * 2023 * * `value`: Amount to transfer.2024 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2025 * * Fungible Mode: The desired number of pieces to transfer.2026 * * Re-Fungible Mode: The desired number of pieces to transfer.2027 **/2028 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]>;2029 /**2030 * Change ownership of an item on behalf of the owner as a non-owner account.2031 * 2032 * See the [`approve`][`Pallet::approve`] method for additional information.2033 * 2034 * After this method executes, one approval is removed from the total so that2035 * the approved address will not be able to transfer this item again from this owner.2036 * 2037 * # Permissions2038 * 2039 * * Collection owner2040 * * Collection admin2041 * * Current item owner2042 * * Address approved by current item owner2043 * 2044 * # Arguments2045 * 2046 * * `from`: Address that currently owns the token.2047 * * `recipient`: Address of the new token-owner-to-be.2048 * * `collection_id`: ID of the collection the item.2049 * * `item_id`: ID of the item to be transferred.2050 * * `value`: Amount to transfer.2051 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.2052 * * Fungible Mode: The desired number of pieces to transfer.2053 * * Re-Fungible Mode: The desired number of pieces to transfer.2054 **/2055 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]>;2056 /**2057 * Generic tx2058 **/2059 [key: string]: SubmittableExtrinsicFunction<ApiType>;2060 };2061 vesting: {2062 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2063 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;2064 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>]>;2065 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]>;2066 /**2067 * Generic tx2068 **/2069 [key: string]: SubmittableExtrinsicFunction<ApiType>;2070 };2071 xcmpQueue: {2072 /**2073 * Resumes all XCM executions for the XCMP queue.2074 * 2075 * Note that this function doesn't change the status of the in/out bound channels.2076 * 2077 * - `origin`: Must pass `ControllerOrigin`.2078 **/2079 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2080 /**2081 * Services a single overweight XCM.2082 * 2083 * - `origin`: Must pass `ExecuteOverweightOrigin`.2084 * - `index`: The index of the overweight XCM to service2085 * - `weight_limit`: The amount of weight that XCM execution may take.2086 * 2087 * Errors:2088 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.2089 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.2090 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.2091 * 2092 * Events:2093 * - `OverweightServiced`: On success.2094 **/2095 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;2096 /**2097 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.2098 * 2099 * - `origin`: Must pass `ControllerOrigin`.2100 **/2101 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;2102 /**2103 * Overwrites the number of pages of messages which must be in the queue after which we drop any further2104 * messages from the channel.2105 * 2106 * - `origin`: Must pass `Root`.2107 * - `new`: Desired value for `QueueConfigData.drop_threshold`2108 **/2109 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2110 /**2111 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that2112 * message sending may recommence after it has been suspended.2113 * 2114 * - `origin`: Must pass `Root`.2115 * - `new`: Desired value for `QueueConfigData.resume_threshold`2116 **/2117 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2118 /**2119 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to2120 * suspend their sending.2121 * 2122 * - `origin`: Must pass `Root`.2123 * - `new`: Desired value for `QueueConfigData.suspend_value`2124 **/2125 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;2126 /**2127 * Overwrites the amount of remaining weight under which we stop processing messages.2128 * 2129 * - `origin`: Must pass `Root`.2130 * - `new`: Desired value for `QueueConfigData.threshold_weight`2131 **/2132 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;2133 /**2134 * Overwrites the speed to which the available weight approaches the maximum weight.2135 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.2136 * 2137 * - `origin`: Must pass `Root`.2138 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.2139 **/2140 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;2141 /**2142 * Overwrite the maximum amount of weight any individual message may consume.2143 * Messages above this weight go into the overweight queue and may only be serviced explicitly.2144 * 2145 * - `origin`: Must pass `Root`.2146 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.2147 **/2148 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;2149 /**2150 * Generic tx2151 **/2152 [key: string]: SubmittableExtrinsicFunction<ApiType>;2153 };2154 xTokens: {2155 /**2156 * Transfer native currencies.2157 * 2158 * `dest_weight_limit` is the weight for XCM execution on the dest2159 * chain, and it would be charged from the transferred assets. If set2160 * below requirements, the execution may fail and assets wouldn't be2161 * received.2162 * 2163 * It's a no-op if any error on local XCM execution or message sending.2164 * Note sending assets out per se doesn't guarantee they would be2165 * received. Receiving depends on if the XCM message could be delivered2166 * by the network, and if the receiving chain would handle2167 * messages correctly.2168 **/2169 transfer: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, XcmVersionedMultiLocation, XcmV2WeightLimit]>;2170 /**2171 * Transfer `MultiAsset`.2172 * 2173 * `dest_weight_limit` is the weight for XCM execution on the dest2174 * chain, and it would be charged from the transferred assets. If set2175 * below requirements, the execution may fail and assets wouldn't be2176 * received.2177 * 2178 * It's a no-op if any error on local XCM execution or message sending.2179 * Note sending assets out per se doesn't guarantee they would be2180 * received. Receiving depends on if the XCM message could be delivered2181 * by the network, and if the receiving chain would handle2182 * messages correctly.2183 **/2184 transferMultiasset: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV2WeightLimit]>;2185 /**2186 * Transfer several `MultiAsset` specifying the item to be used as fee2187 * 2188 * `dest_weight_limit` is the weight for XCM execution on the dest2189 * chain, and it would be charged from the transferred assets. If set2190 * below requirements, the execution may fail and assets wouldn't be2191 * received.2192 * 2193 * `fee_item` is index of the MultiAssets that we want to use for2194 * payment2195 * 2196 * It's a no-op if any error on local XCM execution or message sending.2197 * Note sending assets out per se doesn't guarantee they would be2198 * received. Receiving depends on if the XCM message could be delivered2199 * by the network, and if the receiving chain would handle2200 * messages correctly.2201 **/2202 transferMultiassets: AugmentedSubmittable<(assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAssets, u32, XcmVersionedMultiLocation, XcmV2WeightLimit]>;2203 /**2204 * Transfer `MultiAsset` specifying the fee and amount as separate.2205 * 2206 * `dest_weight_limit` is the weight for XCM execution on the dest2207 * chain, and it would be charged from the transferred assets. If set2208 * below requirements, the execution may fail and assets wouldn't be2209 * received.2210 * 2211 * `fee` is the multiasset to be spent to pay for execution in2212 * destination chain. Both fee and amount will be subtracted form the2213 * callers balance For now we only accept fee and asset having the same2214 * `MultiLocation` id.2215 * 2216 * If `fee` is not high enough to cover for the execution costs in the2217 * destination chain, then the assets will be trapped in the2218 * destination chain2219 * 2220 * It's a no-op if any error on local XCM execution or message sending.2221 * Note sending assets out per se doesn't guarantee they would be2222 * received. Receiving depends on if the XCM message could be delivered2223 * by the network, and if the receiving chain would handle2224 * messages correctly.2225 **/2226 transferMultiassetWithFee: AugmentedSubmittable<(asset: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, fee: XcmVersionedMultiAsset | { V0: any } | { V1: any } | string | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiAsset, XcmVersionedMultiAsset, XcmVersionedMultiLocation, XcmV2WeightLimit]>;2227 /**2228 * Transfer several currencies specifying the item to be used as fee2229 * 2230 * `dest_weight_limit` is the weight for XCM execution on the dest2231 * chain, and it would be charged from the transferred assets. If set2232 * below requirements, the execution may fail and assets wouldn't be2233 * received.2234 * 2235 * `fee_item` is index of the currencies tuple that we want to use for2236 * payment2237 * 2238 * It's a no-op if any error on local XCM execution or message sending.2239 * Note sending assets out per se doesn't guarantee they would be2240 * received. Receiving depends on if the XCM message could be delivered2241 * by the network, and if the receiving chain would handle2242 * messages correctly.2243 **/2244 transferMulticurrencies: AugmentedSubmittable<(currencies: Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>> | ([PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, u128 | AnyNumber | Uint8Array])[], feeItem: u32 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[PalletForeignAssetsAssetIds, u128]>>, u32, XcmVersionedMultiLocation, XcmV2WeightLimit]>;2245 /**2246 * Transfer native currencies specifying the fee and amount as2247 * separate.2248 * 2249 * `dest_weight_limit` is the weight for XCM execution on the dest2250 * chain, and it would be charged from the transferred assets. If set2251 * below requirements, the execution may fail and assets wouldn't be2252 * received.2253 * 2254 * `fee` is the amount to be spent to pay for execution in destination2255 * chain. Both fee and amount will be subtracted form the callers2256 * balance.2257 * 2258 * If `fee` is not high enough to cover for the execution costs in the2259 * destination chain, then the assets will be trapped in the2260 * destination chain2261 * 2262 * It's a no-op if any error on local XCM execution or message sending.2263 * Note sending assets out per se doesn't guarantee they would be2264 * received. Receiving depends on if the XCM message could be delivered2265 * by the network, and if the receiving chain would handle2266 * messages correctly.2267 **/2268 transferWithFee: AugmentedSubmittable<(currencyId: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, fee: u128 | AnyNumber | Uint8Array, dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, destWeightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletForeignAssetsAssetIds, u128, u128, XcmVersionedMultiLocation, XcmV2WeightLimit]>;2269 /**2270 * Generic tx2271 **/2272 [key: string]: SubmittableExtrinsicFunction<ApiType>;2273 };2274 } // AugmentedSubmittables2275} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts122.5 KiBsourcehistory