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 { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, IMethod, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, Call, H160, H256, MultiAddress, Perbill, Permill } from '@polkadot/types/interfaces/runtime';12import type { CumulusPrimitivesParachainInherentParachainInherentData, EthereumLog, EthereumTransactionTransactionV2, OpalRuntimeRuntimeCommonSessionKeys, OrmlVestingVestingSchedule, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, 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';1314export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;15export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;16export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;1718declare module '@polkadot/api-base/types/submittable' {19 interface AugmentedSubmittables<ApiType extends ApiTypes> {20 appPromotion: {21 /**22 * Recalculates interest for the specified number of stakers.23 * If all stakers are not recalculated, the next call of the extrinsic24 * will continue the recalculation, from those stakers for whom this25 * was not perform in last call.26 * 27 * # Permissions28 * 29 * * Pallet admin30 * 31 * # Arguments32 * 33 * * `stakers_number`: the number of stakers for which recalculation will be performed34 **/35 payoutStakers: AugmentedSubmittable<(stakersNumber: Option<u8> | null | Uint8Array | u8 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u8>]>;36 /**37 * Sets an address as the the admin.38 * 39 * # Permissions40 * 41 * * Sudo42 * 43 * # Arguments44 * 45 * * `admin`: account of the new admin.46 **/47 setAdminAddress: AugmentedSubmittable<(admin: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletEvmAccountBasicCrossAccountIdRepr]>;48 /**49 * Sets the pallet to be the sponsor for the collection.50 * 51 * # Permissions52 * 53 * * Pallet admin54 * 55 * # Arguments56 * 57 * * `collection_id`: ID of the collection that will be sponsored by `pallet_id`58 **/59 sponsorCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;60 /**61 * Sets the pallet to be the sponsor for the contract.62 * 63 * # Permissions64 * 65 * * Pallet admin66 * 67 * # Arguments68 * 69 * * `contract_id`: the contract address that will be sponsored by `pallet_id`70 **/71 sponsorContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;72 /**73 * Stakes the amount of native tokens.74 * Sets `amount` to the locked state.75 * The maximum number of stakes for a staker is 10.76 * 77 * # Arguments78 * 79 * * `amount`: in native tokens.80 **/81 stake: AugmentedSubmittable<(amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;82 /**83 * Removes the pallet as the sponsor for the collection.84 * Returns [`NoPermission`][`Error::NoPermission`]85 * if the pallet wasn't the sponsor.86 * 87 * # Permissions88 * 89 * * Pallet admin90 * 91 * # Arguments92 * 93 * * `collection_id`: ID of the collection that is sponsored by `pallet_id`94 **/95 stopSponsoringCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;96 /**97 * Removes the pallet as the sponsor for the contract.98 * Returns [`NoPermission`][`Error::NoPermission`]99 * if the pallet wasn't the sponsor.100 * 101 * # Permissions102 * 103 * * Pallet admin104 * 105 * # Arguments106 * 107 * * `contract_id`: the contract address that is sponsored by `pallet_id`108 **/109 stopSponsoringContract: AugmentedSubmittable<(contractId: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;110 /**111 * Unstakes all stakes.112 * Moves the sum of all stakes to the `reserved` state.113 * After the end of `PendingInterval` this sum becomes completely114 * free for further use.115 **/116 unstake: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;117 /**118 * Generic tx119 **/120 [key: string]: SubmittableExtrinsicFunction<ApiType>;121 };122 authorship: {123 /**124 * Provide a set of uncles.125 **/126 setUncles: AugmentedSubmittable<(newUncles: Vec<SpRuntimeHeader> | (SpRuntimeHeader | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<SpRuntimeHeader>]>;127 /**128 * Generic tx129 **/130 [key: string]: SubmittableExtrinsicFunction<ApiType>;131 };132 balances: {133 /**134 * Exactly as `transfer`, except the origin must be root and the source account may be135 * specified.136 * # <weight>137 * - Same as transfer, but additional read and write because the source account is not138 * assumed to be in the overlay.139 * # </weight>140 **/141 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>]>;142 /**143 * Unreserve some balance from a user by force.144 * 145 * Can only be called by ROOT.146 **/147 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;148 /**149 * Set the balances of a given account.150 * 151 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will152 * also alter the total issuance of the system (`TotalIssuance`) appropriately.153 * If the new free or reserved balance is below the existential deposit,154 * it will reset the account nonce (`frame_system::AccountNonce`).155 * 156 * The dispatch origin for this call is `root`.157 **/158 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>]>;159 /**160 * Transfer some liquid free balance to another account.161 * 162 * `transfer` will set the `FreeBalance` of the sender and receiver.163 * If the sender's account is below the existential deposit as a result164 * of the transfer, the account will be reaped.165 * 166 * The dispatch origin for this call must be `Signed` by the transactor.167 * 168 * # <weight>169 * - Dependent on arguments but not critical, given proper implementations for input config170 * types. See related functions below.171 * - It contains a limited number of reads and writes internally and no complex172 * computation.173 * 174 * Related functions:175 * 176 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.177 * - Transferring balances to accounts that did not exist before will cause178 * `T::OnNewAccount::on_new_account` to be called.179 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.180 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check181 * that the transfer will not kill the origin account.182 * ---------------------------------183 * - Origin account is already in memory, so no DB operations for them.184 * # </weight>185 **/186 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>]>;187 /**188 * Transfer the entire transferable balance from the caller account.189 * 190 * NOTE: This function only attempts to transfer _transferable_ balances. This means that191 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be192 * transferred by this function. To ensure that this function results in a killed account,193 * you might need to prepare the account by removing any reference counters, storage194 * deposits, etc...195 * 196 * The dispatch origin of this call must be Signed.197 * 198 * - `dest`: The recipient of the transfer.199 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all200 * of the funds the account has, causing the sender account to be killed (false), or201 * transfer everything except at least the existential deposit, which will guarantee to202 * keep the sender account alive (true). # <weight>203 * - O(1). Just like transfer, but reading the user's transferable balance first.204 * #</weight>205 **/206 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;207 /**208 * Same as the [`transfer`] call, but with a check that the transfer will not kill the209 * origin account.210 * 211 * 99% of the time you want [`transfer`] instead.212 * 213 * [`transfer`]: struct.Pallet.html#method.transfer214 **/215 transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<u128> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, Compact<u128>]>;216 /**217 * Generic tx218 **/219 [key: string]: SubmittableExtrinsicFunction<ApiType>;220 };221 charging: {222 /**223 * Generic tx224 **/225 [key: string]: SubmittableExtrinsicFunction<ApiType>;226 };227 collatorSelection: {228 /**229 * Add a collator to the list of invulnerable (fixed) collators.230 **/231 addInvulnerable: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;232 /**233 * Force deregister `origin` as a collator candidate as a governing authority, and revoke its license.234 * Note that the collator can only leave on session change.235 * The `LicenseBond` will be unreserved and returned immediately.236 * 237 * This call is not available to `Invulnerable` collators.238 **/239 forceRevokeLicense: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;240 /**241 * Purchase a license on block collation for this account.242 * It does not make it a collator candidate, use `onboard` afterward. The account must243 * (a) already have registered session keys and (b) be able to reserve the `LicenseBond`.244 * 245 * This call is not available to `Invulnerable` collators.246 **/247 getLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;248 /**249 * Deregister `origin` as a collator candidate. Note that the collator can only leave on250 * session change. The license to `onboard` later at any other time will remain.251 * 252 * This call will fail if the total number of candidates would drop below `MinCandidates`. todo:collator maybe not253 **/254 offboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;255 /**256 * Register this account as a candidate for collators for next sessions.257 * The account must already hold a license, and cannot offboard immediately during a session.258 * 259 * This call is not available to `Invulnerable` collators.260 **/261 onboard: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;262 /**263 * Forfeit `origin`'s own license. The `LicenseBond` will be unreserved immediately.264 * 265 * This call is not available to `Invulnerable` collators.266 **/267 releaseLicense: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;268 /**269 * Remove a collator from the list of invulnerable (fixed) collators.270 **/271 removeInvulnerable: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [AccountId32]>;272 /**273 * Set the ideal number of collators. If lowering this number,274 * then the number of running collators could be higher than this figure.275 * Aside from that edge case, there should be no other way to have more collators than the desired number.276 **/277 setDesiredCollators: AugmentedSubmittable<(max: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;278 /**279 * Set the length of the kick threshold.280 * Note that if the length is not a multiple of the session period, it might get inconsistent.281 **/282 setKickThreshold: AugmentedSubmittable<(kickThreshold: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;283 /**284 * Set the candidacy bond amount.285 **/286 setLicenseBond: AugmentedSubmittable<(bond: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u128]>;287 /**288 * Generic tx289 **/290 [key: string]: SubmittableExtrinsicFunction<ApiType>;291 };292 configuration: {293 setAppPromotionConfigurationOverride: AugmentedSubmittable<(configuration: PalletConfigurationAppPromotionConfiguration | { recalculationInterval?: any; pendingInterval?: any; intervalIncome?: any; maxStakersPerCalculation?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletConfigurationAppPromotionConfiguration]>;294 setMinGasPriceOverride: AugmentedSubmittable<(coeff: Option<u64> | null | Uint8Array | u64 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u64>]>;295 setWeightToFeeCoefficientOverride: AugmentedSubmittable<(coeff: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;296 setXcmAllowedLocations: AugmentedSubmittable<(locations: Option<Vec<XcmV1MultiLocation>> | null | Uint8Array | Vec<XcmV1MultiLocation> | (XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Option<Vec<XcmV1MultiLocation>>]>;297 /**298 * Generic tx299 **/300 [key: string]: SubmittableExtrinsicFunction<ApiType>;301 };302 cumulusXcm: {303 /**304 * Generic tx305 **/306 [key: string]: SubmittableExtrinsicFunction<ApiType>;307 };308 dmpQueue: {309 /**310 * Service a single overweight message.311 * 312 * - `origin`: Must pass `ExecuteOverweightOrigin`.313 * - `index`: The index of the overweight message to service.314 * - `weight_limit`: The amount of weight that message execution may take.315 * 316 * Errors:317 * - `Unknown`: Message of `index` is unknown.318 * - `OverLimit`: Message execution may use greater than `weight_limit`.319 * 320 * Events:321 * - `OverweightServiced`: On success.322 **/323 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;324 /**325 * Generic tx326 **/327 [key: string]: SubmittableExtrinsicFunction<ApiType>;328 };329 ethereum: {330 /**331 * Transact an Ethereum transaction.332 **/333 transact: AugmentedSubmittable<(transaction: EthereumTransactionTransactionV2 | { Legacy: any } | { EIP2930: any } | { EIP1559: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionTransactionV2]>;334 /**335 * Generic tx336 **/337 [key: string]: SubmittableExtrinsicFunction<ApiType>;338 };339 evm: {340 /**341 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.342 **/343 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>]>>]>;344 /**345 * Issue an EVM create operation. This is similar to a contract creation transaction in346 * Ethereum.347 **/348 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>]>>]>;349 /**350 * Issue an EVM create2 operation.351 **/352 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>]>>]>;353 /**354 * Withdraw balance from EVM into currency/balances pallet.355 **/356 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;357 /**358 * Generic tx359 **/360 [key: string]: SubmittableExtrinsicFunction<ApiType>;361 };362 evmMigration: {363 /**364 * Start contract migration, inserts contract stub at target address,365 * and marks account as pending, allowing to insert storage366 **/367 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;368 /**369 * Finish contract migration, allows it to be called.370 * It is not possible to alter contract storage via [`Self::set_data`]371 * after this call.372 **/373 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;374 /**375 * Create ethereum events attached to the fake transaction376 **/377 insertEthLogs: AugmentedSubmittable<(logs: Vec<EthereumLog> | (EthereumLog | { address?: any; topics?: any; data?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<EthereumLog>]>;378 /**379 * Create substrate events380 **/381 insertEvents: AugmentedSubmittable<(events: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;382 /**383 * Insert items into contract storage, this method can be called384 * multiple times385 **/386 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;387 /**388 * Generic tx389 **/390 [key: string]: SubmittableExtrinsicFunction<ApiType>;391 };392 foreignAssets: {393 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]>;394 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]>;395 /**396 * Generic tx397 **/398 [key: string]: SubmittableExtrinsicFunction<ApiType>;399 };400 inflation: {401 /**402 * This method sets the inflation start date. Can be only called once.403 * Inflation start block can be backdated and will catch up. The method will create Treasury404 * account if it does not exist and perform the first inflation deposit.405 * 406 * # Permissions407 * 408 * * Root409 * 410 * # Arguments411 * 412 * * inflation_start_relay_block: The relay chain block at which inflation should start413 **/414 startInflation: AugmentedSubmittable<(inflationStartRelayBlock: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;415 /**416 * Generic tx417 **/418 [key: string]: SubmittableExtrinsicFunction<ApiType>;419 };420 maintenance: {421 disable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;422 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;423 /**424 * Generic tx425 **/426 [key: string]: SubmittableExtrinsicFunction<ApiType>;427 };428 parachainSystem: {429 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;430 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;431 /**432 * Set the current validation data.433 * 434 * This should be invoked exactly once per block. It will panic at the finalization435 * phase if the call was not invoked.436 * 437 * The dispatch origin for this call must be `Inherent`438 * 439 * As a side effect, this function upgrades the current validation function440 * if the appropriate time has come.441 **/442 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;443 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;444 /**445 * Generic tx446 **/447 [key: string]: SubmittableExtrinsicFunction<ApiType>;448 };449 polkadotXcm: {450 /**451 * Execute an XCM message from a local, signed, origin.452 * 453 * An event is deposited indicating whether `msg` could be executed completely or only454 * partially.455 * 456 * No more than `max_weight` will be used in its attempted execution. If this is less than the457 * maximum amount of weight that the message could take to be executed, then no execution458 * attempt will be made.459 * 460 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully461 * to completion; only that *some* of it was executed.462 **/463 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;464 /**465 * Set a safe XCM version (the version that XCM should be encoded with if the most recent466 * version a destination can accept is unknown).467 * 468 * - `origin`: Must be Root.469 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.470 **/471 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | Uint8Array | u32 | AnyNumber) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;472 /**473 * Ask a location to notify us regarding their XCM version and any changes to it.474 * 475 * - `origin`: Must be Root.476 * - `location`: The location to which we should subscribe for XCM version notifications.477 **/478 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;479 /**480 * Require that a particular destination should no longer notify us regarding any XCM481 * version changes.482 * 483 * - `origin`: Must be Root.484 * - `location`: The location to which we are currently subscribed for XCM version485 * notifications which we no longer desire.486 **/487 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;488 /**489 * Extoll that a particular destination can be communicated with through a particular490 * version of XCM.491 * 492 * - `origin`: Must be Root.493 * - `location`: The destination that is being described.494 * - `xcm_version`: The latest version of XCM that `location` supports.495 **/496 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;497 /**498 * Transfer some assets from the local chain to the sovereign account of a destination499 * chain and forward a notification XCM.500 * 501 * Fee payment on the destination side is made from the asset in the `assets` vector of502 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight503 * is needed than `weight_limit`, then the operation will fail and the assets send may be504 * at risk.505 * 506 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.507 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send508 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.509 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be510 * an `AccountId32` value.511 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the512 * `dest` side.513 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay514 * fees.515 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.516 **/517 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]>;518 /**519 * Teleport some assets from the local chain to some destination chain.520 * 521 * Fee payment on the destination side is made from the asset in the `assets` vector of522 * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight523 * is needed than `weight_limit`, then the operation will fail and the assets send may be524 * at risk.525 * 526 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.527 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send528 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.529 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be530 * an `AccountId32` value.531 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the532 * `dest` side. May not be empty.533 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay534 * fees.535 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.536 **/537 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]>;538 /**539 * Transfer some assets from the local chain to the sovereign account of a destination540 * chain and forward a notification XCM.541 * 542 * Fee payment on the destination side is made from the asset in the `assets` vector of543 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,544 * with all fees taken as needed from the asset.545 * 546 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.547 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send548 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.549 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be550 * an `AccountId32` value.551 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the552 * `dest` side.553 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay554 * fees.555 **/556 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]>;557 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;558 /**559 * Teleport some assets from the local chain to some destination chain.560 * 561 * Fee payment on the destination side is made from the asset in the `assets` vector of562 * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited,563 * with all fees taken as needed from the asset.564 * 565 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.566 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send567 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.568 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be569 * an `AccountId32` value.570 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the571 * `dest` side. May not be empty.572 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay573 * fees.574 **/575 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]>;576 /**577 * Generic tx578 **/579 [key: string]: SubmittableExtrinsicFunction<ApiType>;580 };581 rmrkCore: {582 /**583 * Accept an NFT sent from another account to self or an owned NFT.584 * 585 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.586 * 587 * # Permissions:588 * - Token-owner-to-be589 * 590 * # Arguments:591 * - `origin`: sender of the transaction592 * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted.593 * - `rmrk_nft_id`: ID of the NFT to be accepted.594 * - `new_owner`: Either the sender's account ID or a sender-owned NFT,595 * whichever the accepted NFT was sent to.596 **/597 acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;598 /**599 * Accept the addition of a newly created pending resource to an existing NFT.600 * 601 * This transaction is needed when a resource is created and assigned to an NFT602 * by a non-owner, i.e. the collection issuer, with one of the603 * [`add_...` transactions](Pallet::add_basic_resource).604 * 605 * # Permissions:606 * - Token owner607 * 608 * # Arguments:609 * - `origin`: sender of the transaction610 * - `rmrk_collection_id`: RMRK collection ID of the NFT.611 * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted.612 * - `resource_id`: ID of the newly created pending resource.613 * accept the addition of a new resource to an existing NFT614 **/615 acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;616 /**617 * Accept the removal of a removal-pending resource from an NFT.618 * 619 * This transaction is needed when a non-owner, i.e. the collection issuer,620 * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT.621 * 622 * # Permissions:623 * - Token owner624 * 625 * # Arguments:626 * - `origin`: sender of the transaction627 * - `rmrk_collection_id`: RMRK collection ID of the NFT.628 * - `rmrk_nft_id`: ID of the NFT with a resource to be removed.629 * - `resource_id`: ID of the removal-pending resource.630 **/631 acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;632 /**633 * Create and set/propose a basic resource for an NFT.634 * 635 * A basic resource is the simplest, lacking a Base and anything that comes with it.636 * See RMRK docs for more information and examples.637 * 638 * # Permissions:639 * - Collection issuer - if not the token owner, adding the resource will warrant640 * the owner's [acceptance](Pallet::accept_resource).641 * 642 * # Arguments:643 * - `origin`: sender of the transaction644 * - `rmrk_collection_id`: RMRK collection ID of the NFT.645 * - `nft_id`: ID of the NFT to assign a resource to.646 * - `resource`: Data of the resource to be created.647 **/648 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]>;649 /**650 * Create and set/propose a composable resource for an NFT.651 * 652 * A composable resource links to a Base and has a subset of its Parts it is composed of.653 * See RMRK docs for more information and examples.654 * 655 * # Permissions:656 * - Collection issuer - if not the token owner, adding the resource will warrant657 * the owner's [acceptance](Pallet::accept_resource).658 * 659 * # Arguments:660 * - `origin`: sender of the transaction661 * - `rmrk_collection_id`: RMRK collection ID of the NFT.662 * - `nft_id`: ID of the NFT to assign a resource to.663 * - `resource`: Data of the resource to be created.664 **/665 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]>;666 /**667 * Create and set/propose a slot resource for an NFT.668 * 669 * A slot resource links to a Base and a slot ID in it which it can fit into.670 * See RMRK docs for more information and examples.671 * 672 * # Permissions:673 * - Collection issuer - if not the token owner, adding the resource will warrant674 * the owner's [acceptance](Pallet::accept_resource).675 * 676 * # Arguments:677 * - `origin`: sender of the transaction678 * - `rmrk_collection_id`: RMRK collection ID of the NFT.679 * - `nft_id`: ID of the NFT to assign a resource to.680 * - `resource`: Data of the resource to be created.681 **/682 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]>;683 /**684 * Burn an NFT, destroying it and its nested tokens up to the specified limit.685 * If the burning budget is exceeded, the transaction is reverted.686 * 687 * This is the way to burn a nested token as well.688 * 689 * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively).690 * 691 * # Permissions:692 * * Token owner693 * 694 * # Arguments:695 * - `origin`: sender of the transaction696 * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to.697 * - `nft_id`: ID of the NFT to be destroyed.698 * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction699 * is reverted if there are more tokens to burn in the nesting tree than this number.700 * This is primarily a mechanism of transaction weight control.701 **/702 burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;703 /**704 * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection).705 * 706 * # Permissions:707 * * Collection issuer708 * 709 * # Arguments:710 * - `origin`: sender of the transaction711 * - `collection_id`: RMRK collection ID to change the issuer of.712 * - `new_issuer`: Collection's new issuer.713 **/714 changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, MultiAddress]>;715 /**716 * Create a new collection of NFTs.717 * 718 * # Permissions:719 * * Anyone - will be assigned as the issuer of the collection.720 * 721 * # Arguments:722 * - `origin`: sender of the transaction723 * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed.724 * - `max`: Optional maximum number of tokens.725 * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs.726 * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed.727 **/728 createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option<u32> | null | Uint8Array | u32 | AnyNumber, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, Option<u32>, Bytes]>;729 /**730 * Destroy a collection.731 * 732 * Only empty collections can be destroyed. If it has any tokens, they must be burned first.733 * 734 * # Permissions:735 * * Collection issuer736 * 737 * # Arguments:738 * - `origin`: sender of the transaction739 * - `collection_id`: RMRK ID of the collection to destroy.740 **/741 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;742 /**743 * "Lock" the collection and prevent new token creation. Cannot be undone.744 * 745 * # Permissions:746 * * Collection issuer747 * 748 * # Arguments:749 * - `origin`: sender of the transaction750 * - `collection_id`: RMRK ID of the collection to lock.751 **/752 lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;753 /**754 * Mint an NFT in a specified collection.755 * 756 * # Permissions:757 * * Collection issuer758 * 759 * # Arguments:760 * - `origin`: sender of the transaction761 * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer).762 * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed.763 * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed.764 * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed.765 * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed.766 * - `transferable`: Can this NFT be transferred? Cannot be changed.767 * - `resources`: Resource data to be added to the NFT immediately after minting.768 **/769 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>>]>;770 /**771 * Reject an NFT sent from another account to self or owned NFT.772 * The NFT in question will not be sent back and burnt instead.773 * 774 * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first.775 * 776 * # Permissions:777 * - Token-owner-to-be-not778 * 779 * # Arguments:780 * - `origin`: sender of the transaction781 * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected.782 * - `rmrk_nft_id`: ID of the NFT to be rejected.783 **/784 rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;785 /**786 * Remove and erase a resource from an NFT.787 * 788 * If the sender does not own the NFT, then it will be pending confirmation,789 * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner.790 * 791 * # Permissions792 * - Collection issuer793 * 794 * # Arguments795 * - `origin`: sender of the transaction796 * - `rmrk_collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to.797 * - `nft_id`: ID of the NFT with a resource to be removed.798 * - `resource_id`: ID of the resource to be removed.799 **/800 removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u32]>;801 /**802 * Transfer an NFT from an account/NFT A to another account/NFT B.803 * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`].804 * 805 * If the target owner is an NFT owned by another account, then the NFT will enter806 * the pending state and will have to be accepted by the other account.807 * 808 * # Permissions:809 * - Token owner810 * 811 * # Arguments:812 * - `origin`: sender of the transaction813 * - `rmrk_collection_id`: RMRK ID of the collection of the NFT to be transferred.814 * - `rmrk_nft_id`: ID of the NFT to be transferred.815 * - `new_owner`: New owner of the nft which can be either an account or a NFT.816 **/817 send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>;818 /**819 * Set a different order of resource priorities for an NFT. Priorities can be used,820 * for example, for order of rendering.821 * 822 * Note that the priorities are not updated automatically, and are an empty vector823 * by default. There is no pre-set definition for the order to be particular,824 * it can be interpreted arbitrarily use-case by use-case.825 * 826 * # Permissions:827 * - Token owner828 * 829 * # Arguments:830 * - `origin`: sender of the transaction831 * - `rmrk_collection_id`: RMRK collection ID of the NFT.832 * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for.833 * - `priorities`: Ordered vector of resource IDs.834 **/835 setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec<u32> | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<u32>]>;836 /**837 * Add or edit a custom user property, a key-value pair, describing the metadata838 * of a token or a collection, on either one of these.839 * 840 * Note that in this proxy implementation many details regarding RMRK are stored841 * as scoped properties prefixed with "rmrk:", normally inaccessible842 * to external transactions and RPCs.843 * 844 * # Permissions:845 * - Collection issuer - in case of collection property846 * - Token owner - in case of NFT property847 * 848 * # Arguments:849 * - `origin`: sender of the transaction850 * - `rmrk_collection_id`: RMRK collection ID.851 * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection.852 * - `key`: Key of the custom property to be referenced by.853 * - `value`: Value of the custom property to be stored.854 **/855 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]>;856 /**857 * Generic tx858 **/859 [key: string]: SubmittableExtrinsicFunction<ApiType>;860 };861 rmrkEquip: {862 /**863 * Create a new Base.864 * 865 * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)866 * 867 * # Permissions868 * - Anyone - will be assigned as the issuer of the Base.869 * 870 * # Arguments:871 * - `origin`: Caller, will be assigned as the issuer of the Base872 * - `base_type`: Arbitrary media type, e.g. "svg".873 * - `symbol`: Arbitrary client-chosen symbol.874 * - `parts`: Array of Fixed and Slot Parts composing the Base,875 * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).876 **/877 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>]>;878 /**879 * Update the array of Collections allowed to be equipped to a Base's specified Slot Part.880 * 881 * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).882 * 883 * # Permissions:884 * - Base issuer885 * 886 * # Arguments:887 * - `origin`: sender of the transaction888 * - `base_id`: Base containing the Slot Part to be updated.889 * - `slot_id`: Slot Part whose Equippable List is being updated .890 * - `equippables`: List of equippables that will override the current Equippables list.891 **/892 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]>;893 /**894 * Add a Theme to a Base.895 * A Theme named "default" is required prior to adding other Themes.896 * 897 * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).898 * 899 * # Permissions:900 * - Base issuer901 * 902 * # Arguments:903 * - `origin`: sender of the transaction904 * - `base_id`: Base ID containing the Theme to be updated.905 * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an906 * array of [key, value, inherit].907 * - `key`: Arbitrary BoundedString, defined by client.908 * - `value`: Arbitrary BoundedString, defined by client.909 * - `inherit`: Optional bool.910 **/911 themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, RmrkTraitsTheme]>;912 /**913 * Generic tx914 **/915 [key: string]: SubmittableExtrinsicFunction<ApiType>;916 };917 session: {918 /**919 * Removes any session key(s) of the function caller.920 * 921 * This doesn't take effect until the next session.922 * 923 * The dispatch origin of this function must be Signed and the account must be either be924 * convertible to a validator ID using the chain's typical addressing system (this usually925 * means being a controller account) or directly convertible into a validator ID (which926 * usually means being a stash account).927 * 928 * # <weight>929 * - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length930 * of `T::Keys::key_ids()` which is fixed.931 * - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`932 * - DbWrites: `NextKeys`, `origin account`933 * - DbWrites per key id: `KeyOwner`934 * # </weight>935 **/936 purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;937 /**938 * Sets the session key(s) of the function caller to `keys`.939 * Allows an account to set its session key prior to becoming a validator.940 * This doesn't take effect until the next session.941 * 942 * The dispatch origin of this function must be signed.943 * 944 * # <weight>945 * - Complexity: `O(1)`. Actual cost depends on the number of length of946 * `T::Keys::key_ids()` which is fixed.947 * - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`948 * - DbWrites: `origin account`, `NextKeys`949 * - DbReads per key id: `KeyOwner`950 * - DbWrites per key id: `KeyOwner`951 * # </weight>952 **/953 setKeys: AugmentedSubmittable<(keys: OpalRuntimeRuntimeCommonSessionKeys | { aura?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [OpalRuntimeRuntimeCommonSessionKeys, Bytes]>;954 /**955 * Generic tx956 **/957 [key: string]: SubmittableExtrinsicFunction<ApiType>;958 };959 structure: {960 /**961 * Generic tx962 **/963 [key: string]: SubmittableExtrinsicFunction<ApiType>;964 };965 sudo: {966 /**967 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo968 * key.969 * 970 * The dispatch origin for this call must be _Signed_.971 * 972 * # <weight>973 * - O(1).974 * - Limited storage reads.975 * - One DB change.976 * # </weight>977 **/978 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;979 /**980 * Authenticates the sudo key and dispatches a function call with `Root` origin.981 * 982 * The dispatch origin for this call must be _Signed_.983 * 984 * # <weight>985 * - O(1).986 * - Limited storage reads.987 * - One DB write (event).988 * - Weight of derivative `call` execution + 10,000.989 * # </weight>990 **/991 sudo: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;992 /**993 * Authenticates the sudo key and dispatches a function call with `Signed` origin from994 * a given account.995 * 996 * The dispatch origin for this call must be _Signed_.997 * 998 * # <weight>999 * - O(1).1000 * - Limited storage reads.1001 * - One DB write (event).1002 * - Weight of derivative `call` execution + 10,000.1003 * # </weight>1004 **/1005 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]>;1006 /**1007 * Authenticates the sudo key and dispatches a function call with `Root` origin.1008 * This function does not check the weight of the call, and instead allows the1009 * Sudo user to specify the weight of the call.1010 * 1011 * The dispatch origin for this call must be _Signed_.1012 * 1013 * # <weight>1014 * - O(1).1015 * - The weight of this call is defined by the caller.1016 * # </weight>1017 **/1018 sudoUncheckedWeight: AugmentedSubmittable<(call: Call | IMethod | string | Uint8Array, weight: SpWeightsWeightV2Weight | { refTime?: any; proofSize?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, SpWeightsWeightV2Weight]>;1019 /**1020 * Generic tx1021 **/1022 [key: string]: SubmittableExtrinsicFunction<ApiType>;1023 };1024 system: {1025 /**1026 * A dispatch that will fill the block weight up to the given ratio.1027 **/1028 fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;1029 /**1030 * Kill all storage items with a key that starts with the given prefix.1031 * 1032 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under1033 * the prefix we are removing to accurately calculate the weight of this function.1034 **/1035 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;1036 /**1037 * Kill some items from storage.1038 **/1039 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;1040 /**1041 * Make some on-chain remark.1042 * 1043 * # <weight>1044 * - `O(1)`1045 * # </weight>1046 **/1047 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1048 /**1049 * Make some on-chain remark and emit event.1050 **/1051 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1052 /**1053 * Set the new runtime code.1054 * 1055 * # <weight>1056 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`1057 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is1058 * expensive).1059 * - 1 storage write (codec `O(C)`).1060 * - 1 digest item.1061 * - 1 event.1062 * The weight of this function is dependent on the runtime, but generally this is very1063 * expensive. We will treat this as a full block.1064 * # </weight>1065 **/1066 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1067 /**1068 * Set the new runtime code without doing any checks of the given `code`.1069 * 1070 * # <weight>1071 * - `O(C)` where `C` length of `code`1072 * - 1 storage write (codec `O(C)`).1073 * - 1 digest item.1074 * - 1 event.1075 * The weight of this function is dependent on the runtime. We will treat this as a full1076 * block. # </weight>1077 **/1078 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1079 /**1080 * Set the number of pages in the WebAssembly environment's heap.1081 **/1082 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1083 /**1084 * Set some items of storage.1085 **/1086 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1087 /**1088 * Generic tx1089 **/1090 [key: string]: SubmittableExtrinsicFunction<ApiType>;1091 };1092 testUtils: {1093 batchAll: AugmentedSubmittable<(calls: Vec<Call> | (Call | IMethod | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Call>]>;1094 enable: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1095 incTestValue: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1096 justTakeFee: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1097 setTestValue: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1098 setTestValueAndRollback: AugmentedSubmittable<(value: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1099 /**1100 * Generic tx1101 **/1102 [key: string]: SubmittableExtrinsicFunction<ApiType>;1103 };1104 timestamp: {1105 /**1106 * Set the current time.1107 * 1108 * This call should be invoked exactly once per block. It will panic at the finalization1109 * phase, if this call hasn't been invoked by that time.1110 * 1111 * The timestamp should be greater than the previous one by the amount specified by1112 * `MinimumPeriod`.1113 * 1114 * The dispatch origin for this call must be `Inherent`.1115 * 1116 * # <weight>1117 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1118 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1119 * `on_finalize`)1120 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1121 * # </weight>1122 **/1123 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1124 /**1125 * Generic tx1126 **/1127 [key: string]: SubmittableExtrinsicFunction<ApiType>;1128 };1129 tokens: {1130 /**1131 * Exactly as `transfer`, except the origin must be root and the source1132 * account may be specified.1133 * 1134 * The dispatch origin for this call must be _Root_.1135 * 1136 * - `source`: The sender of the transfer.1137 * - `dest`: The recipient of the transfer.1138 * - `currency_id`: currency type.1139 * - `amount`: free balance amount to tranfer.1140 **/1141 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>]>;1142 /**1143 * Set the balances of a given account.1144 * 1145 * This will alter `FreeBalance` and `ReservedBalance` in storage. it1146 * will also decrease the total issuance of the system1147 * (`TotalIssuance`). If the new free or reserved balance is below the1148 * existential deposit, it will reap the `AccountInfo`.1149 * 1150 * The dispatch origin for this call is `root`.1151 **/1152 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>]>;1153 /**1154 * Transfer some liquid free balance to another account.1155 * 1156 * `transfer` will set the `FreeBalance` of the sender and receiver.1157 * It will decrease the total issuance of the system by the1158 * `TransferFee`. If the sender's account is below the existential1159 * deposit as a result of the transfer, the account will be reaped.1160 * 1161 * The dispatch origin for this call must be `Signed` by the1162 * transactor.1163 * 1164 * - `dest`: The recipient of the transfer.1165 * - `currency_id`: currency type.1166 * - `amount`: free balance amount to tranfer.1167 **/1168 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>]>;1169 /**1170 * Transfer all remaining balance to the given account.1171 * 1172 * NOTE: This function only attempts to transfer _transferable_1173 * balances. This means that any locked, reserved, or existential1174 * deposits (when `keep_alive` is `true`), will not be transferred by1175 * this function. To ensure that this function results in a killed1176 * account, you might need to prepare the account by removing any1177 * reference counters, storage deposits, etc...1178 * 1179 * The dispatch origin for this call must be `Signed` by the1180 * transactor.1181 * 1182 * - `dest`: The recipient of the transfer.1183 * - `currency_id`: currency type.1184 * - `keep_alive`: A boolean to determine if the `transfer_all`1185 * operation should send all of the funds the account has, causing1186 * the sender account to be killed (false), or transfer everything1187 * except at least the existential deposit, which will guarantee to1188 * keep the sender account alive (true).1189 **/1190 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]>;1191 /**1192 * Same as the [`transfer`] call, but with a check that the transfer1193 * will not kill the origin account.1194 * 1195 * 99% of the time you want [`transfer`] instead.1196 * 1197 * The dispatch origin for this call must be `Signed` by the1198 * transactor.1199 * 1200 * - `dest`: The recipient of the transfer.1201 * - `currency_id`: currency type.1202 * - `amount`: free balance amount to tranfer.1203 **/1204 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>]>;1205 /**1206 * Generic tx1207 **/1208 [key: string]: SubmittableExtrinsicFunction<ApiType>;1209 };1210 treasury: {1211 /**1212 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1213 * and the original deposit will be returned.1214 * 1215 * May only be called from `T::ApproveOrigin`.1216 * 1217 * # <weight>1218 * - Complexity: O(1).1219 * - DbReads: `Proposals`, `Approvals`1220 * - DbWrite: `Approvals`1221 * # </weight>1222 **/1223 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1224 /**1225 * Put forward a suggestion for spending. A deposit proportional to the value1226 * is reserved and slashed if the proposal is rejected. It is returned once the1227 * proposal is awarded.1228 * 1229 * # <weight>1230 * - Complexity: O(1)1231 * - DbReads: `ProposalCount`, `origin account`1232 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1233 * # </weight>1234 **/1235 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]>;1236 /**1237 * Reject a proposed spend. The original deposit will be slashed.1238 * 1239 * May only be called from `T::RejectOrigin`.1240 * 1241 * # <weight>1242 * - Complexity: O(1)1243 * - DbReads: `Proposals`, `rejected proposer account`1244 * - DbWrites: `Proposals`, `rejected proposer account`1245 * # </weight>1246 **/1247 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1248 /**1249 * Force a previously approved proposal to be removed from the approval queue.1250 * The original deposit will no longer be returned.1251 * 1252 * May only be called from `T::RejectOrigin`.1253 * - `proposal_id`: The index of a proposal1254 * 1255 * # <weight>1256 * - Complexity: O(A) where `A` is the number of approvals1257 * - Db reads and writes: `Approvals`1258 * # </weight>1259 * 1260 * Errors:1261 * - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,1262 * i.e., the proposal has not been approved. This could also mean the proposal does not1263 * exist altogether, thus there is no way it would have been approved in the first place.1264 **/1265 removeApproval: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1266 /**1267 * Propose and approve a spend of treasury funds.1268 * 1269 * - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.1270 * - `amount`: The amount to be transferred from the treasury to the `beneficiary`.1271 * - `beneficiary`: The destination account for the transfer.1272 * 1273 * NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the1274 * beneficiary.1275 **/1276 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]>;1277 /**1278 * Generic tx1279 **/1280 [key: string]: SubmittableExtrinsicFunction<ApiType>;1281 };1282 unique: {1283 /**1284 * Add an admin to a collection.1285 * 1286 * NFT Collection can be controlled by multiple admin addresses1287 * (some which can also be servers, for example). Admins can issue1288 * and burn NFTs, as well as add and remove other admins,1289 * but cannot change NFT or Collection ownership.1290 * 1291 * # Permissions1292 * 1293 * * Collection owner1294 * * Collection admin1295 * 1296 * # Arguments1297 * 1298 * * `collection_id`: ID of the Collection to add an admin for.1299 * * `new_admin`: Address of new admin to add.1300 **/1301 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1302 /**1303 * Add an address to allow list.1304 * 1305 * # Permissions1306 * 1307 * * Collection owner1308 * * Collection admin1309 * 1310 * # Arguments1311 * 1312 * * `collection_id`: ID of the modified collection.1313 * * `address`: ID of the address to be added to the allowlist.1314 **/1315 addToAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1316 /**1317 * Allow a non-permissioned address to transfer or burn an item.1318 * 1319 * # Permissions1320 * 1321 * * Collection owner1322 * * Collection admin1323 * * Current item owner1324 * 1325 * # Arguments1326 * 1327 * * `spender`: Account to be approved to make specific transactions on non-owned tokens.1328 * * `collection_id`: ID of the collection the item belongs to.1329 * * `item_id`: ID of the item transactions on which are now approved.1330 * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs).1331 * Set to 0 to revoke the approval.1332 **/1333 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]>;1334 /**1335 * Destroy a token on behalf of the owner as a non-owner account.1336 * 1337 * See also: [`approve`][`Pallet::approve`].1338 * 1339 * After this method executes, one approval is removed from the total so that1340 * the approved address will not be able to transfer this item again from this owner.1341 * 1342 * # Permissions1343 * 1344 * * Collection owner1345 * * Collection admin1346 * * Current token owner1347 * * Address approved by current item owner1348 * 1349 * # Arguments1350 * 1351 * * `from`: The owner of the burning item.1352 * * `collection_id`: ID of the collection to which the item belongs.1353 * * `item_id`: ID of item to burn.1354 * * `value`: Number of pieces to burn.1355 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1356 * * Fungible Mode: The desired number of pieces to burn.1357 * * Re-Fungible Mode: The desired number of pieces to burn.1358 **/1359 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]>;1360 /**1361 * Destroy an item.1362 * 1363 * # Permissions1364 * 1365 * * Collection owner1366 * * Collection admin1367 * * Current item owner1368 * 1369 * # Arguments1370 * 1371 * * `collection_id`: ID of the collection to which the item belongs.1372 * * `item_id`: ID of item to burn.1373 * * `value`: Number of pieces of the item to destroy.1374 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1375 * * Fungible Mode: The desired number of pieces to burn.1376 * * Re-Fungible Mode: The desired number of pieces to burn.1377 **/1378 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1379 /**1380 * Change the owner of the collection.1381 * 1382 * # Permissions1383 * 1384 * * Collection owner1385 * 1386 * # Arguments1387 * 1388 * * `collection_id`: ID of the modified collection.1389 * * `new_owner`: ID of the account that will become the owner.1390 **/1391 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1392 /**1393 * Confirm own sponsorship of a collection, becoming the sponsor.1394 * 1395 * An invitation must be pending, see [`set_collection_sponsor`][`Pallet::set_collection_sponsor`].1396 * Sponsor can pay the fees of a transaction instead of the sender,1397 * but only within specified limits.1398 * 1399 * # Permissions1400 * 1401 * * Sponsor-to-be1402 * 1403 * # Arguments1404 * 1405 * * `collection_id`: ID of the collection with the pending sponsor.1406 **/1407 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1408 /**1409 * Create a collection of tokens.1410 * 1411 * Each Token may have multiple properties encoded as an array of bytes1412 * of certain length. The initial owner of the collection is set1413 * to the address that signed the transaction and can be changed later.1414 * 1415 * Prefer the more advanced [`create_collection_ex`][`Pallet::create_collection_ex`] instead.1416 * 1417 * # Permissions1418 * 1419 * * Anyone - becomes the owner of the new collection.1420 * 1421 * # Arguments1422 * 1423 * * `collection_name`: Wide-character string with collection name1424 * (limit [`MAX_COLLECTION_NAME_LENGTH`]).1425 * * `collection_description`: Wide-character string with collection description1426 * (limit [`MAX_COLLECTION_DESCRIPTION_LENGTH`]).1427 * * `token_prefix`: Byte string containing the token prefix to mark a collection1428 * to which a token belongs (limit [`MAX_TOKEN_PREFIX_LENGTH`]).1429 * * `mode`: Type of items stored in the collection and type dependent data.1430 **/1431 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]>;1432 /**1433 * Create a collection with explicit parameters.1434 * 1435 * Prefer it to the deprecated [`create_collection`][`Pallet::create_collection`] method.1436 * 1437 * # Permissions1438 * 1439 * * Anyone - becomes the owner of the new collection.1440 * 1441 * # Arguments1442 * 1443 * * `data`: Explicit data of a collection used for its creation.1444 **/1445 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]>;1446 /**1447 * Mint an item within a collection.1448 * 1449 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1450 * 1451 * # Permissions1452 * 1453 * * Collection owner1454 * * Collection admin1455 * * Anyone if1456 * * Allow List is enabled, and1457 * * Address is added to allow list, and1458 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1459 * 1460 * # Arguments1461 * 1462 * * `collection_id`: ID of the collection to which an item would belong.1463 * * `owner`: Address of the initial owner of the item.1464 * * `data`: Token data describing the item to store on chain.1465 **/1466 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]>;1467 /**1468 * Create multiple items within a collection.1469 * 1470 * A collection must exist first, see [`create_collection_ex`][`Pallet::create_collection_ex`].1471 * 1472 * # Permissions1473 * 1474 * * Collection owner1475 * * Collection admin1476 * * Anyone if1477 * * Allow List is enabled, and1478 * * Address is added to the allow list, and1479 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1480 * 1481 * # Arguments1482 * 1483 * * `collection_id`: ID of the collection to which the tokens would belong.1484 * * `owner`: Address of the initial owner of the tokens.1485 * * `items_data`: Vector of data describing each item to be created.1486 **/1487 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>]>;1488 /**1489 * Create multiple items within a collection with explicitly specified initial parameters.1490 * 1491 * # Permissions1492 * 1493 * * Collection owner1494 * * Collection admin1495 * * Anyone if1496 * * Allow List is enabled, and1497 * * Address is added to allow list, and1498 * * MintPermission is enabled (see [`set_collection_permissions`][`Pallet::set_collection_permissions`])1499 * 1500 * # Arguments1501 * 1502 * * `collection_id`: ID of the collection to which the tokens would belong.1503 * * `data`: Explicit item creation data.1504 **/1505 createMultipleItemsEx: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, data: UpDataStructsCreateItemExData | { NFT: any } | { Fungible: any } | { RefungibleMultipleItems: any } | { RefungibleMultipleOwners: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCreateItemExData]>;1506 /**1507 * Delete specified collection properties.1508 * 1509 * # Permissions1510 * 1511 * * Collection Owner1512 * * Collection Admin1513 * 1514 * # Arguments1515 * 1516 * * `collection_id`: ID of the modified collection.1517 * * `property_keys`: Vector of keys of the properties to be deleted.1518 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1519 **/1520 deleteCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<Bytes>]>;1521 /**1522 * Delete specified token properties. Currently properties only work with NFTs.1523 * 1524 * # Permissions1525 * 1526 * * Depends on collection's token property permissions and specified property mutability:1527 * * Collection owner1528 * * Collection admin1529 * * Token owner1530 * 1531 * # Arguments1532 * 1533 * * `collection_id`: ID of the collection to which the token belongs.1534 * * `token_id`: ID of the modified token.1535 * * `property_keys`: Vector of keys of the properties to be deleted.1536 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1537 **/1538 deleteTokenProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, propertyKeys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, u32, Vec<Bytes>]>;1539 /**1540 * Destroy a collection if no tokens exist within.1541 * 1542 * # Permissions1543 * 1544 * * Collection owner1545 * 1546 * # Arguments1547 * 1548 * * `collection_id`: Collection to destroy.1549 **/1550 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1551 /**1552 * Repairs a collection if the data was somehow corrupted.1553 * 1554 * # Arguments1555 * 1556 * * `collection_id`: ID of the collection to repair.1557 **/1558 forceRepairCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1559 /**1560 * Repairs a token if the data was somehow corrupted.1561 * 1562 * # Arguments1563 * 1564 * * `collection_id`: ID of the collection the item belongs to.1565 * * `item_id`: ID of the item.1566 **/1567 forceRepairItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1568 /**1569 * Remove admin of a collection.1570 * 1571 * An admin address can remove itself. List of admins may become empty,1572 * in which case only Collection Owner will be able to add an Admin.1573 * 1574 * # Permissions1575 * 1576 * * Collection owner1577 * * Collection admin1578 * 1579 * # Arguments1580 * 1581 * * `collection_id`: ID of the collection to remove the admin for.1582 * * `account_id`: Address of the admin to remove.1583 **/1584 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1585 /**1586 * Remove a collection's a sponsor, making everyone pay for their own transactions.1587 * 1588 * # Permissions1589 * 1590 * * Collection owner1591 * 1592 * # Arguments1593 * 1594 * * `collection_id`: ID of the collection with the sponsor to remove.1595 **/1596 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1597 /**1598 * Remove an address from allow list.1599 * 1600 * # Permissions1601 * 1602 * * Collection owner1603 * * Collection admin1604 * 1605 * # Arguments1606 * 1607 * * `collection_id`: ID of the modified collection.1608 * * `address`: ID of the address to be removed from the allowlist.1609 **/1610 removeFromAllowList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;1611 /**1612 * Re-partition a refungible token, while owning all of its parts/pieces.1613 * 1614 * # Permissions1615 * 1616 * * Token owner (must own every part)1617 * 1618 * # Arguments1619 * 1620 * * `collection_id`: ID of the collection the RFT belongs to.1621 * * `token_id`: ID of the RFT.1622 * * `amount`: New number of parts/pieces into which the token shall be partitioned.1623 **/1624 repartition: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, tokenId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;1625 /**1626 * Sets or unsets the approval of a given operator.1627 * 1628 * The `operator` is allowed to transfer all tokens of the `owner` on their behalf.1629 * 1630 * # Arguments1631 * 1632 * * `owner`: Token owner1633 * * `operator`: Operator1634 * * `approve`: Should operator status be granted or revoked?1635 **/1636 setAllowanceForAll: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, operator: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, bool]>;1637 /**1638 * Set specific limits of a collection. Empty, or None fields mean chain default.1639 * 1640 * # Permissions1641 * 1642 * * Collection owner1643 * * Collection admin1644 * 1645 * # Arguments1646 * 1647 * * `collection_id`: ID of the modified collection.1648 * * `new_limit`: New limits of the collection. Fields that are not set (None)1649 * will not overwrite the old ones.1650 **/1651 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]>;1652 /**1653 * Set specific permissions of a collection. Empty, or None fields mean chain default.1654 * 1655 * # Permissions1656 * 1657 * * Collection owner1658 * * Collection admin1659 * 1660 * # Arguments1661 * 1662 * * `collection_id`: ID of the modified collection.1663 * * `new_permission`: New permissions of the collection. Fields that are not set (None)1664 * will not overwrite the old ones.1665 **/1666 setCollectionPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newPermission: UpDataStructsCollectionPermissions | { access?: any; mintMode?: any; nesting?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, UpDataStructsCollectionPermissions]>;1667 /**1668 * Add or change collection properties.1669 * 1670 * # Permissions1671 * 1672 * * Collection owner1673 * * Collection admin1674 * 1675 * # Arguments1676 * 1677 * * `collection_id`: ID of the modified collection.1678 * * `properties`: Vector of key-value pairs stored as the collection's metadata.1679 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1680 **/1681 setCollectionProperties: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, properties: Vec<UpDataStructsProperty> | (UpDataStructsProperty | { key?: any; value?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsProperty>]>;1682 /**1683 * Set (invite) a new collection sponsor.1684 * 1685 * If successful, confirmation from the sponsor-to-be will be pending.1686 * 1687 * # Permissions1688 * 1689 * * Collection owner1690 * * Collection admin1691 * 1692 * # Arguments1693 * 1694 * * `collection_id`: ID of the modified collection.1695 * * `new_sponsor`: ID of the account of the sponsor-to-be.1696 **/1697 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;1698 /**1699 * Add or change token properties according to collection's permissions.1700 * Currently properties only work with NFTs.1701 * 1702 * # Permissions1703 * 1704 * * Depends on collection's token property permissions and specified property mutability:1705 * * Collection owner1706 * * Collection admin1707 * * Token owner1708 * 1709 * See [`set_token_property_permissions`][`Pallet::set_token_property_permissions`].1710 * 1711 * # Arguments1712 * 1713 * * `collection_id: ID of the collection to which the token belongs.1714 * * `token_id`: ID of the modified token.1715 * * `properties`: Vector of key-value pairs stored as the token's metadata.1716 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1717 **/1718 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>]>;1719 /**1720 * Add or change token property permissions of a collection.1721 * 1722 * Without a permission for a particular key, a property with that key1723 * cannot be created in a token.1724 * 1725 * # Permissions1726 * 1727 * * Collection owner1728 * * Collection admin1729 * 1730 * # Arguments1731 * 1732 * * `collection_id`: ID of the modified collection.1733 * * `property_permissions`: Vector of permissions for property keys.1734 * Keys support Latin letters, `-`, `_`, and `.` as symbols.1735 **/1736 setTokenPropertyPermissions: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, propertyPermissions: Vec<UpDataStructsPropertyKeyPermission> | (UpDataStructsPropertyKeyPermission | { key?: any; permission?: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, Vec<UpDataStructsPropertyKeyPermission>]>;1737 /**1738 * Completely allow or disallow transfers for a particular collection.1739 * 1740 * # Permissions1741 * 1742 * * Collection owner1743 * 1744 * # Arguments1745 * 1746 * * `collection_id`: ID of the collection.1747 * * `value`: New value of the flag, are transfers allowed?1748 **/1749 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;1750 /**1751 * Change ownership of the token.1752 * 1753 * # Permissions1754 * 1755 * * Collection owner1756 * * Collection admin1757 * * Current token owner1758 * 1759 * # Arguments1760 * 1761 * * `recipient`: Address of token recipient.1762 * * `collection_id`: ID of the collection the item belongs to.1763 * * `item_id`: ID of the item.1764 * * Non-Fungible Mode: Required.1765 * * Fungible Mode: Ignored.1766 * * Re-Fungible Mode: Required.1767 * 1768 * * `value`: Amount to transfer.1769 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1770 * * Fungible Mode: The desired number of pieces to transfer.1771 * * Re-Fungible Mode: The desired number of pieces to transfer.1772 **/1773 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]>;1774 /**1775 * Change ownership of an item on behalf of the owner as a non-owner account.1776 * 1777 * See the [`approve`][`Pallet::approve`] method for additional information.1778 * 1779 * After this method executes, one approval is removed from the total so that1780 * the approved address will not be able to transfer this item again from this owner.1781 * 1782 * # Permissions1783 * 1784 * * Collection owner1785 * * Collection admin1786 * * Current item owner1787 * * Address approved by current item owner1788 * 1789 * # Arguments1790 * 1791 * * `from`: Address that currently owns the token.1792 * * `recipient`: Address of the new token-owner-to-be.1793 * * `collection_id`: ID of the collection the item.1794 * * `item_id`: ID of the item to be transferred.1795 * * `value`: Amount to transfer.1796 * * Non-Fungible Mode: An NFT is indivisible, there is always 1 corresponding to an ID.1797 * * Fungible Mode: The desired number of pieces to transfer.1798 * * Re-Fungible Mode: The desired number of pieces to transfer.1799 **/1800 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]>;1801 /**1802 * Generic tx1803 **/1804 [key: string]: SubmittableExtrinsicFunction<ApiType>;1805 };1806 vesting: {1807 claim: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1808 claimFor: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1809 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>]>;1810 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]>;1811 /**1812 * Generic tx1813 **/1814 [key: string]: SubmittableExtrinsicFunction<ApiType>;1815 };1816 xcmpQueue: {1817 /**1818 * Resumes all XCM executions for the XCMP queue.1819 * 1820 * Note that this function doesn't change the status of the in/out bound channels.1821 * 1822 * - `origin`: Must pass `ControllerOrigin`.1823 **/1824 resumeXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1825 /**1826 * Services a single overweight XCM.1827 * 1828 * - `origin`: Must pass `ExecuteOverweightOrigin`.1829 * - `index`: The index of the overweight XCM to service1830 * - `weight_limit`: The amount of weight that XCM execution may take.1831 * 1832 * Errors:1833 * - `BadOverweightIndex`: XCM under `index` is not found in the `Overweight` storage map.1834 * - `BadXcm`: XCM under `index` cannot be properly decoded into a valid XCM format.1835 * - `WeightOverLimit`: XCM execution may use greater `weight_limit`.1836 * 1837 * Events:1838 * - `OverweightServiced`: On success.1839 **/1840 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;1841 /**1842 * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin.1843 * 1844 * - `origin`: Must pass `ControllerOrigin`.1845 **/1846 suspendXcmExecution: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1847 /**1848 * Overwrites the number of pages of messages which must be in the queue after which we drop any further1849 * messages from the channel.1850 * 1851 * - `origin`: Must pass `Root`.1852 * - `new`: Desired value for `QueueConfigData.drop_threshold`1853 **/1854 updateDropThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1855 /**1856 * Overwrites the number of pages of messages which the queue must be reduced to before it signals that1857 * message sending may recommence after it has been suspended.1858 * 1859 * - `origin`: Must pass `Root`.1860 * - `new`: Desired value for `QueueConfigData.resume_threshold`1861 **/1862 updateResumeThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1863 /**1864 * Overwrites the number of pages of messages which must be in the queue for the other side to be told to1865 * suspend their sending.1866 * 1867 * - `origin`: Must pass `Root`.1868 * - `new`: Desired value for `QueueConfigData.suspend_value`1869 **/1870 updateSuspendThreshold: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;1871 /**1872 * Overwrites the amount of remaining weight under which we stop processing messages.1873 * 1874 * - `origin`: Must pass `Root`.1875 * - `new`: Desired value for `QueueConfigData.threshold_weight`1876 **/1877 updateThresholdWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1878 /**1879 * Overwrites the speed to which the available weight approaches the maximum weight.1880 * A lower number results in a faster progression. A value of 1 makes the entire weight available initially.1881 * 1882 * - `origin`: Must pass `Root`.1883 * - `new`: Desired value for `QueueConfigData.weight_restrict_decay`.1884 **/1885 updateWeightRestrictDecay: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1886 /**1887 * Overwrite the maximum amount of weight any individual message may consume.1888 * Messages above this weight go into the overweight queue and may only be serviced explicitly.1889 * 1890 * - `origin`: Must pass `Root`.1891 * - `new`: Desired value for `QueueConfigData.xcmp_max_individual_weight`.1892 **/1893 updateXcmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1894 /**1895 * Generic tx1896 **/1897 [key: string]: SubmittableExtrinsicFunction<ApiType>;1898 };1899 xTokens: {1900 /**1901 * Transfer native currencies.1902 * 1903 * `dest_weight_limit` is the weight for XCM execution on the dest1904 * chain, and it would be charged from the transferred assets. If set1905 * below requirements, the execution may fail and assets wouldn't be1906 * received.1907 * 1908 * It's a no-op if any error on local XCM execution or message sending.1909 * Note sending assets out per se doesn't guarantee they would be1910 * received. Receiving depends on if the XCM message could be delivered1911 * by the network, and if the receiving chain would handle1912 * messages correctly.1913 **/1914 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]>;1915 /**1916 * Transfer `MultiAsset`.1917 * 1918 * `dest_weight_limit` is the weight for XCM execution on the dest1919 * chain, and it would be charged from the transferred assets. If set1920 * below requirements, the execution may fail and assets wouldn't be1921 * received.1922 * 1923 * It's a no-op if any error on local XCM execution or message sending.1924 * Note sending assets out per se doesn't guarantee they would be1925 * received. Receiving depends on if the XCM message could be delivered1926 * by the network, and if the receiving chain would handle1927 * messages correctly.1928 **/1929 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]>;1930 /**1931 * Transfer several `MultiAsset` specifying the item to be used as fee1932 * 1933 * `dest_weight_limit` is the weight for XCM execution on the dest1934 * chain, and it would be charged from the transferred assets. If set1935 * below requirements, the execution may fail and assets wouldn't be1936 * received.1937 * 1938 * `fee_item` is index of the MultiAssets that we want to use for1939 * payment1940 * 1941 * It's a no-op if any error on local XCM execution or message sending.1942 * Note sending assets out per se doesn't guarantee they would be1943 * received. Receiving depends on if the XCM message could be delivered1944 * by the network, and if the receiving chain would handle1945 * messages correctly.1946 **/1947 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]>;1948 /**1949 * Transfer `MultiAsset` specifying the fee and amount as separate.1950 * 1951 * `dest_weight_limit` is the weight for XCM execution on the dest1952 * chain, and it would be charged from the transferred assets. If set1953 * below requirements, the execution may fail and assets wouldn't be1954 * received.1955 * 1956 * `fee` is the multiasset to be spent to pay for execution in1957 * destination chain. Both fee and amount will be subtracted form the1958 * callers balance For now we only accept fee and asset having the same1959 * `MultiLocation` id.1960 * 1961 * If `fee` is not high enough to cover for the execution costs in the1962 * destination chain, then the assets will be trapped in the1963 * destination chain1964 * 1965 * It's a no-op if any error on local XCM execution or message sending.1966 * Note sending assets out per se doesn't guarantee they would be1967 * received. Receiving depends on if the XCM message could be delivered1968 * by the network, and if the receiving chain would handle1969 * messages correctly.1970 **/1971 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]>;1972 /**1973 * Transfer several currencies specifying the item to be used as fee1974 * 1975 * `dest_weight_limit` is the weight for XCM execution on the dest1976 * chain, and it would be charged from the transferred assets. If set1977 * below requirements, the execution may fail and assets wouldn't be1978 * received.1979 * 1980 * `fee_item` is index of the currencies tuple that we want to use for1981 * payment1982 * 1983 * It's a no-op if any error on local XCM execution or message sending.1984 * Note sending assets out per se doesn't guarantee they would be1985 * received. Receiving depends on if the XCM message could be delivered1986 * by the network, and if the receiving chain would handle1987 * messages correctly.1988 **/1989 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]>;1990 /**1991 * Transfer native currencies specifying the fee and amount as1992 * separate.1993 * 1994 * `dest_weight_limit` is the weight for XCM execution on the dest1995 * chain, and it would be charged from the transferred assets. If set1996 * below requirements, the execution may fail and assets wouldn't be1997 * received.1998 * 1999 * `fee` is the amount to be spent to pay for execution in destination2000 * chain. Both fee and amount will be subtracted form the callers2001 * balance.2002 * 2003 * If `fee` is not high enough to cover for the execution costs in the2004 * destination chain, then the assets will be trapped in the2005 * destination chain2006 * 2007 * It's a no-op if any error on local XCM execution or message sending.2008 * Note sending assets out per se doesn't guarantee they would be2009 * received. Receiving depends on if the XCM message could be delivered2010 * by the network, and if the receiving chain would handle2011 * messages correctly.2012 **/2013 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]>;2014 /**2015 * Generic tx2016 **/2017 [key: string]: SubmittableExtrinsicFunction<ApiType>;2018 };2019 } // AugmentedSubmittables2020} // declare moduledifftreelog
source
tests/src/interfaces/augment-api-tx.ts109.7 KiBsourcehistory