1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34import type { EthereumTransactionLegacyTransaction } from './ethereum';5import type { NftDataStructsAccessMode, NftDataStructsCollectionLimits, NftDataStructsCollectionMode, NftDataStructsCreateItemData, NftDataStructsMetaUpdatePermission, NftDataStructsSchemaVersion, PalletCommonAccountBasicCrossAccountIdRepr } from './nft';6import type { CumulusPrimitivesParachainInherentParachainInherentData } from './polkadot';7import type { ApiTypes, SubmittableExtrinsic } from '@polkadot/api/types';8import type { Bytes, Compact, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types';9import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';10import type { AccountId32, Call, H160, H256, MultiAddress, Perbill } from '@polkadot/types/interfaces/runtime';11import type { PalletVestingVestingInfo, SpCoreChangesTrieChangesTrieConfiguration, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup';12import type { AnyNumber, ITuple } from '@polkadot/types/types';1314declare module '@polkadot/api/types/submittable' {15 export interface AugmentedSubmittables<ApiType> {16 balances: {17 /**18 * Exactly as `transfer`, except the origin must be root and the source account may be19 * specified.20 * # <weight>21 * - Same as transfer, but additional read and write because the source account is not22 * assumed to be in the overlay.23 * # </weight>24 **/25 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>]>;26 /**27 * Unreserve some balance from a user by force.28 * 29 * Can only be called by ROOT.30 **/31 forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, u128]>;32 /**33 * Set the balances of a given account.34 * 35 * This will alter `FreeBalance` and `ReservedBalance` in storage. it will36 * also decrease the total issuance of the system (`TotalIssuance`).37 * If the new free or reserved balance is below the existential deposit,38 * it will reset the account nonce (`frame_system::AccountNonce`).39 * 40 * The dispatch origin for this call is `root`.41 * 42 * # <weight>43 * - Independent of the arguments.44 * - Contains a limited number of reads and writes.45 * ---------------------46 * - Base Weight:47 * - Creating: 27.56 µs48 * - Killing: 35.11 µs49 * - DB Weight: 1 Read, 1 Write to `who`50 * # </weight>51 **/52 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>]>;53 /**54 * Transfer some liquid free balance to another account.55 * 56 * `transfer` will set the `FreeBalance` of the sender and receiver.57 * It will decrease the total issuance of the system by the `TransferFee`.58 * If the sender's account is below the existential deposit as a result59 * of the transfer, the account will be reaped.60 * 61 * The dispatch origin for this call must be `Signed` by the transactor.62 * 63 * # <weight>64 * - Dependent on arguments but not critical, given proper implementations for input config65 * types. See related functions below.66 * - It contains a limited number of reads and writes internally and no complex67 * computation.68 * 69 * Related functions:70 * 71 * - `ensure_can_withdraw` is always called internally but has a bounded complexity.72 * - Transferring balances to accounts that did not exist before will cause73 * `T::OnNewAccount::on_new_account` to be called.74 * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.75 * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check76 * that the transfer will not kill the origin account.77 * ---------------------------------78 * - Base Weight: 73.64 µs, worst case scenario (account created, account removed)79 * - DB Weight: 1 Read and 1 Write to destination account80 * - Origin account is already in memory, so no DB operations for them.81 * # </weight>82 **/83 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>]>;84 /**85 * Transfer the entire transferable balance from the caller account.86 * 87 * NOTE: This function only attempts to transfer _transferable_ balances. This means that88 * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be89 * transferred by this function. To ensure that this function results in a killed account,90 * you might need to prepare the account by removing any reference counters, storage91 * deposits, etc...92 * 93 * The dispatch origin of this call must be Signed.94 * 95 * - `dest`: The recipient of the transfer.96 * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all97 * of the funds the account has, causing the sender account to be killed (false), or98 * transfer everything except at least the existential deposit, which will guarantee to99 * keep the sender account alive (true). # <weight>100 * - O(1). Just like transfer, but reading the user's transferable balance first.101 * #</weight>102 **/103 transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, bool]>;104 /**105 * Same as the [`transfer`] call, but with a check that the transfer will not kill the106 * origin account.107 * 108 * 99% of the time you want [`transfer`] instead.109 * 110 * [`transfer`]: struct.Pallet.html#method.transfer111 * # <weight>112 * - Cheaper than transfer because account cannot be killed.113 * - Base Weight: 51.4 µs114 * - DB Weight: 1 Read and 1 Write to dest (sender is in overlay already)115 * #</weight>116 **/117 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>]>;118 /**119 * Generic tx120 **/121 [key: string]: SubmittableExtrinsicFunction<ApiType>;122 };123 charging: {124 /**125 * Generic tx126 **/127 [key: string]: SubmittableExtrinsicFunction<ApiType>;128 };129 cumulusXcm: {130 /**131 * Generic tx132 **/133 [key: string]: SubmittableExtrinsicFunction<ApiType>;134 };135 dmpQueue: {136 /**137 * Service a single overweight message.138 * 139 * - `origin`: Must pass `ExecuteOverweightOrigin`.140 * - `index`: The index of the overweight message to service.141 * - `weight_limit`: The amount of weight that message execution may take.142 * 143 * Errors:144 * - `Unknown`: Message of `index` is unknown.145 * - `OverLimit`: Message execution may use greater than `weight_limit`.146 * 147 * Events:148 * - `OverweightServiced`: On success.149 **/150 serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64, u64]>;151 /**152 * Generic tx153 **/154 [key: string]: SubmittableExtrinsicFunction<ApiType>;155 };156 ethereum: {157 /**158 * Transact an Ethereum transaction.159 **/160 transact: AugmentedSubmittable<(transaction: EthereumTransactionLegacyTransaction | { nonce?: any; gasPrice?: any; gasLimit?: any; action?: any; value?: any; input?: any; signature?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [EthereumTransactionLegacyTransaction]>;161 /**162 * Generic tx163 **/164 [key: string]: SubmittableExtrinsicFunction<ApiType>;165 };166 evm: {167 /**168 * Issue an EVM call operation. This is similar to a message call transaction in Ethereum.169 **/170 call: AugmentedSubmittable<(source: H160 | string | Uint8Array, target: H160 | string | Uint8Array, input: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, gasPrice: U256 | AnyNumber | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, H160, Bytes, U256, u64, U256, Option<U256>]>;171 /**172 * Issue an EVM create operation. This is similar to a contract creation transaction in173 * Ethereum.174 **/175 create: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, gasPrice: U256 | AnyNumber | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes, U256, u64, U256, Option<U256>]>;176 /**177 * Issue an EVM create2 operation.178 **/179 create2: AugmentedSubmittable<(source: H160 | string | Uint8Array, init: Bytes | string | Uint8Array, salt: H256 | string | Uint8Array, value: U256 | AnyNumber | Uint8Array, gasLimit: u64 | AnyNumber | Uint8Array, gasPrice: U256 | AnyNumber | Uint8Array, nonce: Option<U256> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes, H256, U256, u64, U256, Option<U256>]>;180 /**181 * Withdraw balance from EVM into currency/balances pallet.182 **/183 withdraw: AugmentedSubmittable<(address: H160 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, u128]>;184 /**185 * Generic tx186 **/187 [key: string]: SubmittableExtrinsicFunction<ApiType>;188 };189 evmMigration: {190 begin: AugmentedSubmittable<(address: H160 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160]>;191 finish: AugmentedSubmittable<(address: H160 | string | Uint8Array, code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H160, Bytes]>;192 setData: AugmentedSubmittable<(address: H160 | string | Uint8Array, data: Vec<ITuple<[H256, H256]>> | ([H256 | string | Uint8Array, H256 | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [H160, Vec<ITuple<[H256, H256]>>]>;193 /**194 * Generic tx195 **/196 [key: string]: SubmittableExtrinsicFunction<ApiType>;197 };198 inflation: {199 /**200 * Generic tx201 **/202 [key: string]: SubmittableExtrinsicFunction<ApiType>;203 };204 nft: {205 /**206 * Adds an admin of the Collection.207 * NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.208 * 209 * # Permissions210 * 211 * * Collection Owner.212 * * Collection Admin.213 * 214 * # Arguments215 * 216 * * collection_id: ID of the Collection to add admin for.217 * 218 * * new_admin_id: Address of new admin to add.219 **/220 addCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newAdminId: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;221 /**222 * Add an address to white list.223 * 224 * # Permissions225 * 226 * * Collection Owner227 * * Collection Admin228 * 229 * # Arguments230 * 231 * * collection_id.232 * 233 * * address.234 **/235 addToWhiteList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;236 /**237 * Set, change, or remove approved address to transfer the ownership of the NFT.238 * 239 * # Permissions240 * 241 * * Collection Owner242 * * Collection Admin243 * * Current NFT owner244 * 245 * # Arguments246 * 247 * * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).248 * 249 * * collection_id.250 * 251 * * item_id: ID of the item.252 **/253 approve: AugmentedSubmittable<(spender: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletCommonAccountBasicCrossAccountIdRepr, u32, u32, u128]>;254 /**255 * Destroys a concrete instance of NFT on behalf of the owner256 * See also: [`approve`]257 * 258 * # Permissions259 * 260 * * Collection Owner.261 * * Collection Admin.262 * * Current NFT Owner.263 * 264 * # Arguments265 * 266 * * collection_id: ID of the collection.267 * 268 * * item_id: ID of NFT to burn.269 * 270 * * from: owner of item271 **/272 burnFrom: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, from: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr, u32, u128]>;273 /**274 * Destroys a concrete instance of NFT.275 * 276 * # Permissions277 * 278 * * Collection Owner.279 * * Collection Admin.280 * * Current NFT Owner.281 * 282 * # Arguments283 * 284 * * collection_id: ID of the collection.285 * 286 * * item_id: ID of NFT to burn.287 **/288 burnItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, u128]>;289 /**290 * Change the owner of the collection.291 * 292 * # Permissions293 * 294 * * Collection Owner.295 * 296 * # Arguments297 * 298 * * collection_id.299 * 300 * * new_owner.301 **/302 changeCollectionOwner: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newOwner: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;303 /**304 * # Permissions305 * 306 * * Sponsor.307 * 308 * # Arguments309 * 310 * * collection_id.311 **/312 confirmSponsorship: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;313 /**314 * This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.315 * 316 * # Permissions317 * 318 * * Anyone.319 * 320 * # Arguments321 * 322 * * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.323 * 324 * * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.325 * 326 * * token_prefix: UTF-8 string with token prefix.327 * 328 * * mode: [CollectionMode] collection type and type dependent data.329 **/330 createCollection: AugmentedSubmittable<(collectionName: Vec<u16> | (u16 | AnyNumber | Uint8Array)[], collectionDescription: Vec<u16> | (u16 | AnyNumber | Uint8Array)[], tokenPrefix: Bytes | string | Uint8Array, mode: NftDataStructsCollectionMode | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Vec<u16>, Vec<u16>, Bytes, NftDataStructsCollectionMode]>;331 /**332 * This method creates a concrete instance of NFT Collection created with CreateCollection method.333 * 334 * # Permissions335 * 336 * * Collection Owner.337 * * Collection Admin.338 * * Anyone if339 * * White List is enabled, and340 * * Address is added to white list, and341 * * MintPermission is enabled (see SetMintPermission method)342 * 343 * # Arguments344 * 345 * * collection_id: ID of the collection.346 * 347 * * owner: Address, initial owner of the NFT.348 * 349 * * data: Token data to store on chain.350 **/351 createItem: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, owner: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, data: NftDataStructsCreateItemData | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr, NftDataStructsCreateItemData]>;352 /**353 * This method creates multiple items in a collection created with CreateCollection method.354 * 355 * # Permissions356 * 357 * * Collection Owner.358 * * Collection Admin.359 * * Anyone if360 * * White List is enabled, and361 * * Address is added to white list, and362 * * MintPermission is enabled (see SetMintPermission method)363 * 364 * # Arguments365 * 366 * * collection_id: ID of the collection.367 * 368 * * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].369 * 370 * * owner: Address, initial owner of the NFT.371 **/372 createMultipleItems: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, owner: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, itemsData: Vec<NftDataStructsCreateItemData> | (NftDataStructsCreateItemData | { NFT: any } | { Fungible: any } | { ReFungible: any } | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr, Vec<NftDataStructsCreateItemData>]>;373 /**374 * **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.375 * 376 * # Permissions377 * 378 * * Collection Owner.379 * 380 * # Arguments381 * 382 * * collection_id: collection to destroy.383 **/384 destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;385 /**386 * Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.387 * 388 * # Permissions389 * 390 * * Collection Owner.391 * * Collection Admin.392 * 393 * # Arguments394 * 395 * * collection_id: ID of the Collection to remove admin for.396 * 397 * * account_id: Address of admin to remove.398 **/399 removeCollectionAdmin: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, accountId: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;400 /**401 * Switch back to pay-per-own-transaction model.402 * 403 * # Permissions404 * 405 * * Collection owner.406 * 407 * # Arguments408 * 409 * * collection_id.410 **/411 removeCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32]>;412 /**413 * Remove an address from white list.414 * 415 * # Permissions416 * 417 * * Collection Owner418 * * Collection Admin419 * 420 * # Arguments421 * 422 * * collection_id.423 * 424 * * address.425 **/426 removeFromWhiteList: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, address: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;427 setCollectionLimits: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newLimit: NftDataStructsCollectionLimits | { accountTokenOwnershipLimit?: any; sponsoredDataSize?: any; sponsoredDataRateLimit?: any; tokenLimit?: any; sponsorTransferTimeout?: any; ownerCanTransfer?: any; ownerCanDestroy?: any; transfersEnabled?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, NftDataStructsCollectionLimits]>;428 /**429 * # Permissions430 * 431 * * Collection Owner432 * 433 * # Arguments434 * 435 * * collection_id.436 * 437 * * new_sponsor.438 **/439 setCollectionSponsor: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newSponsor: AccountId32 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, AccountId32]>;440 /**441 * Set const on-chain data schema.442 * 443 * # Permissions444 * 445 * * Collection Owner446 * * Collection Admin447 * 448 * # Arguments449 * 450 * * collection_id.451 * 452 * * schema: String representing the const on-chain data schema.453 **/454 setConstOnChainSchema: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, schema: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Bytes]>;455 /**456 * Set meta_update_permission value for particular collection457 * 458 * # Permissions459 * 460 * * Collection Owner.461 * 462 * # Arguments463 * 464 * * collection_id: ID of the collection.465 * 466 * * value: New flag value.467 **/468 setMetaUpdatePermissionFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: NftDataStructsMetaUpdatePermission | 'ItemOwner' | 'Admin' | 'None' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, NftDataStructsMetaUpdatePermission]>;469 /**470 * Allows Anyone to create tokens if:471 * * White List is enabled, and472 * * Address is added to white list, and473 * * This method was called with True parameter474 * 475 * # Permissions476 * * Collection Owner477 * 478 * # Arguments479 * 480 * * collection_id.481 * 482 * * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.483 **/484 setMintPermission: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, mintPermission: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;485 /**486 * Set off-chain data schema.487 * 488 * # Permissions489 * 490 * * Collection Owner491 * * Collection Admin492 * 493 * # Arguments494 * 495 * * collection_id.496 * 497 * * schema: String representing the offchain data schema.498 **/499 setOffchainSchema: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, schema: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Bytes]>;500 /**501 * Toggle between normal and white list access for the methods with access for `Anyone`.502 * 503 * # Permissions504 * 505 * * Collection Owner.506 * 507 * # Arguments508 * 509 * * collection_id.510 * 511 * * mode: [AccessMode]512 **/513 setPublicAccessMode: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, mode: NftDataStructsAccessMode | 'Normal' | 'WhiteList' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, NftDataStructsAccessMode]>;514 /**515 * Set schema standard516 * ImageURL517 * Unique518 * 519 * # Permissions520 * 521 * * Collection Owner522 * * Collection Admin523 * 524 * # Arguments525 * 526 * * collection_id.527 * 528 * * schema: SchemaVersion: enum529 **/530 setSchemaVersion: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, version: NftDataStructsSchemaVersion | 'ImageURL' | 'Unique' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, NftDataStructsSchemaVersion]>;531 /**532 * Set transfers_enabled value for particular collection533 * 534 * # Permissions535 * 536 * * Collection Owner.537 * 538 * # Arguments539 * 540 * * collection_id: ID of the collection.541 * 542 * * value: New flag value.543 **/544 setTransfersEnabledFlag: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, value: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, bool]>;545 /**546 * Set off-chain data schema.547 * 548 * # Permissions549 * 550 * * Collection Owner551 * * Collection Admin552 * 553 * # Arguments554 * 555 * * collection_id.556 * 557 * * schema: String representing the offchain data schema.558 **/559 setVariableMetaData: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, data: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32, Bytes]>;560 /**561 * Set variable on-chain data schema.562 * 563 * # Permissions564 * 565 * * Collection Owner566 * * Collection Admin567 * 568 * # Arguments569 * 570 * * collection_id.571 * 572 * * schema: String representing the variable on-chain data schema.573 **/574 setVariableOnChainSchema: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, schema: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, Bytes]>;575 /**576 * Change ownership of the token.577 * 578 * # Permissions579 * 580 * * Collection Owner581 * * Collection Admin582 * * Current NFT owner583 * 584 * # Arguments585 * 586 * * recipient: Address of token recipient.587 * 588 * * collection_id.589 * 590 * * item_id: ID of the item591 * * Non-Fungible Mode: Required.592 * * Fungible Mode: Ignored.593 * * Re-Fungible Mode: Required.594 * 595 * * value: Amount to transfer.596 * * Non-Fungible Mode: Ignored597 * * Fungible Mode: Must specify transferred amount598 * * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)599 **/600 transfer: AugmentedSubmittable<(recipient: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletCommonAccountBasicCrossAccountIdRepr, u32, u32, u128]>;601 /**602 * Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.603 * 604 * # Permissions605 * * Collection Owner606 * * Collection Admin607 * * Current NFT owner608 * * Address approved by current NFT owner609 * 610 * # Arguments611 * 612 * * from: Address that owns token.613 * 614 * * recipient: Address of token recipient.615 * 616 * * collection_id.617 * 618 * * item_id: ID of the item.619 * 620 * * value: Amount to transfer.621 **/622 transferFrom: AugmentedSubmittable<(from: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, recipient: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonAccountBasicCrossAccountIdRepr, u32, u32, u128]>;623 /**624 * Generic tx625 **/626 [key: string]: SubmittableExtrinsicFunction<ApiType>;627 };628 nftPayment: {629 /**630 * Generic tx631 **/632 [key: string]: SubmittableExtrinsicFunction<ApiType>;633 };634 parachainSystem: {635 authorizeUpgrade: AugmentedSubmittable<(codeHash: H256 | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [H256]>;636 enactAuthorizedUpgrade: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;637 /**638 * Set the current validation data.639 * 640 * This should be invoked exactly once per block. It will panic at the finalization641 * phase if the call was not invoked.642 * 643 * The dispatch origin for this call must be `Inherent`644 * 645 * As a side effect, this function upgrades the current validation function646 * if the appropriate time has come.647 **/648 setValidationData: AugmentedSubmittable<(data: CumulusPrimitivesParachainInherentParachainInherentData | { validationData?: any; relayChainState?: any; downwardMessages?: any; horizontalMessages?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [CumulusPrimitivesParachainInherentParachainInherentData]>;649 sudoSendUpwardMessage: AugmentedSubmittable<(message: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;650 /**651 * Generic tx652 **/653 [key: string]: SubmittableExtrinsicFunction<ApiType>;654 };655 polkadotXcm: {656 /**657 * Execute an XCM message from a local, signed, origin.658 * 659 * An event is deposited indicating whether `msg` could be executed completely or only660 * partially.661 * 662 * No more than `max_weight` will be used in its attempted execution. If this is less than the663 * maximum amount of weight that the message could take to be executed, then no execution664 * attempt will be made.665 * 666 * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully667 * to completion; only that *some* of it was executed.668 **/669 execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedXcm, u64]>;670 /**671 * Set a safe XCM version (the version that XCM should be encoded with if the most recent672 * version a destination can accept is unknown).673 * 674 * - `origin`: Must be Root.675 * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable.676 **/677 forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option<u32> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<u32>]>;678 /**679 * Ask a location to notify us regarding their XCM version and any changes to it.680 * 681 * - `origin`: Must be Root.682 * - `location`: The location to which we should subscribe for XCM version notifications.683 **/684 forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;685 /**686 * Require that a particular destination should no longer notify us regarding any XCM687 * version changes.688 * 689 * - `origin`: Must be Root.690 * - `location`: The location to which we are currently subscribed for XCM version691 * notifications which we no longer desire.692 **/693 forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation]>;694 /**695 * Extoll that a particular destination can be communicated with through a particular696 * version of XCM.697 * 698 * - `origin`: Must be Root.699 * - `location`: The destination that is being described.700 * - `xcm_version`: The latest version of XCM that `location` supports.701 **/702 forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmV1MultiLocation, u32]>;703 /**704 * Transfer some assets from the local chain to the sovereign account of a destination chain and forward705 * a notification XCM.706 * 707 * Fee payment on the destination side is made from the first asset listed in the `assets` vector.708 * 709 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.710 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send711 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.712 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be713 * an `AccountId32` value.714 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the715 * `dest` side.716 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay717 * fees.718 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.719 **/720 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]>;721 /**722 * Teleport some assets from the local chain to some destination chain.723 * 724 * Fee payment on the destination side is made from the first asset listed in the `assets` vector.725 * 726 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.727 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send728 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.729 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be730 * an `AccountId32` value.731 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the732 * `dest` side. May not be empty.733 * - `dest_weight`: Equal to the total weight on `dest` of the XCM message734 * `Teleport { assets, effects: [ BuyExecution{..}, DepositAsset{..} ] }`.735 * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.736 **/737 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]>;738 /**739 * Transfer some assets from the local chain to the sovereign account of a destination chain and forward740 * a notification XCM.741 * 742 * Fee payment on the destination side is made from the first asset listed in the `assets` vector and743 * fee-weight is calculated locally and thus remote weights are assumed to be equal to744 * local weights.745 * 746 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.747 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send748 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.749 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be750 * an `AccountId32` value.751 * - `assets`: The assets to be withdrawn. This should include the assets used to pay the fee on the752 * `dest` side.753 * - `fee_asset_item`: The index into `assets` of the item which should be used to pay754 * fees.755 **/756 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]>;757 send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [XcmVersionedMultiLocation, XcmVersionedXcm]>;758 /**759 * Teleport some assets from the local chain to some destination chain.760 * 761 * Fee payment on the destination side is made from the first asset listed in the `assets` vector and762 * fee-weight is calculated locally and thus remote weights are assumed to be equal to763 * local weights.764 * 765 * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.766 * - `dest`: Destination context for the assets. Will typically be `X2(Parent, Parachain(..))` to send767 * from parachain to parachain, or `X1(Parachain(..))` to send from relay to parachain.768 * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will generally be769 * an `AccountId32` value.770 * - `assets`: The assets to be withdrawn. The first item should be the currency used to to pay the fee on the771 * `dest` side. May not be empty.772 * - `dest_weight`: Equal to the total weight on `dest` of the XCM message773 * `Teleport { assets, effects: [ BuyExecution{..}, DepositAsset{..} ] }`.774 **/775 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]>;776 /**777 * Generic tx778 **/779 [key: string]: SubmittableExtrinsicFunction<ApiType>;780 };781 scheduler: {782 /**783 * Cancel an anonymously scheduled task.784 * 785 * # <weight>786 * - S = Number of already scheduled calls787 * - Base Weight: 22.15 + 2.869 * S µs788 * - DB Weight:789 * - Read: Agenda790 * - Write: Agenda, Lookup791 * - Will use base weight of 100 which should be good for up to 30 scheduled calls792 * # </weight>793 **/794 cancel: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;795 /**796 * Cancel a named scheduled task.797 * 798 * # <weight>799 * - S = Number of already scheduled calls800 * - Base Weight: 24.91 + 2.907 * S µs801 * - DB Weight:802 * - Read: Agenda, Lookup803 * - Write: Agenda, Lookup804 * - Will use base weight of 100 which should be good for up to 30 scheduled calls805 * # </weight>806 **/807 cancelNamed: AugmentedSubmittable<(id: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;808 /**809 * Anonymously schedule a task.810 * 811 * # <weight>812 * - S = Number of already scheduled calls813 * - Base Weight: 22.29 + .126 * S µs814 * - DB Weight:815 * - Read: Agenda816 * - Write: Agenda817 * - Will use base weight of 25 which should be good for up to 30 scheduled calls818 * # </weight>819 **/820 schedule: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: Call) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;821 /**822 * Anonymously schedule a task after a delay.823 * 824 * # <weight>825 * Same as [`schedule`].826 * # </weight>827 **/828 scheduleAfter: AugmentedSubmittable<(after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: Call) => SubmittableExtrinsic<ApiType>, [u32, Option<ITuple<[u32, u32]>>, u8, Call]>;829 /**830 * Schedule a named task.831 * 832 * # <weight>833 * - S = Number of already scheduled calls834 * - Base Weight: 29.6 + .159 * S µs835 * - DB Weight:836 * - Read: Agenda, Lookup837 * - Write: Agenda, Lookup838 * - Will use base weight of 35 which should be good for more than 30 scheduled calls839 * # </weight>840 **/841 scheduleNamed: AugmentedSubmittable<(id: Bytes | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: Call) => SubmittableExtrinsic<ApiType>, [Bytes, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;842 /**843 * Schedule a named task after a delay.844 * 845 * # <weight>846 * Same as [`schedule_named`].847 * # </weight>848 **/849 scheduleNamedAfter: AugmentedSubmittable<(id: Bytes | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option<ITuple<[u32, u32]>> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: Call) => SubmittableExtrinsic<ApiType>, [Bytes, u32, Option<ITuple<[u32, u32]>>, u8, Call]>;850 /**851 * Generic tx852 **/853 [key: string]: SubmittableExtrinsicFunction<ApiType>;854 };855 sudo: {856 /**857 * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo858 * key.859 * 860 * The dispatch origin for this call must be _Signed_.861 * 862 * # <weight>863 * - O(1).864 * - Limited storage reads.865 * - One DB change.866 * # </weight>867 **/868 setKey: AugmentedSubmittable<(updated: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;869 /**870 * Authenticates the sudo key and dispatches a function call with `Root` origin.871 * 872 * The dispatch origin for this call must be _Signed_.873 * 874 * # <weight>875 * - O(1).876 * - Limited storage reads.877 * - One DB write (event).878 * - Weight of derivative `call` execution + 10,000.879 * # </weight>880 **/881 sudo: AugmentedSubmittable<(call: Call) => SubmittableExtrinsic<ApiType>, [Call]>;882 /**883 * Authenticates the sudo key and dispatches a function call with `Signed` origin from884 * a given account.885 * 886 * The dispatch origin for this call must be _Signed_.887 * 888 * # <weight>889 * - O(1).890 * - Limited storage reads.891 * - One DB write (event).892 * - Weight of derivative `call` execution + 10,000.893 * # </weight>894 **/895 sudoAs: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, call: Call) => SubmittableExtrinsic<ApiType>, [MultiAddress, Call]>;896 /**897 * Authenticates the sudo key and dispatches a function call with `Root` origin.898 * This function does not check the weight of the call, and instead allows the899 * Sudo user to specify the weight of the call.900 * 901 * The dispatch origin for this call must be _Signed_.902 * 903 * # <weight>904 * - O(1).905 * - The weight of this call is defined by the caller.906 * # </weight>907 **/908 sudoUncheckedWeight: AugmentedSubmittable<(call: Call, weight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, u64]>;909 /**910 * Generic tx911 **/912 [key: string]: SubmittableExtrinsicFunction<ApiType>;913 };914 system: {915 /**916 * A dispatch that will fill the block weight up to the given ratio.917 **/918 fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;919 /**920 * Kill all storage items with a key that starts with the given prefix.921 * 922 * **NOTE:** We rely on the Root origin to provide us the number of subkeys under923 * the prefix we are removing to accurately calculate the weight of this function.924 * 925 * # <weight>926 * - `O(P)` where `P` amount of keys with prefix `prefix`927 * - `P` storage deletions.928 * - Base Weight: 0.834 * P µs929 * - Writes: Number of subkeys + 1930 * # </weight>931 **/932 killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes, u32]>;933 /**934 * Kill some items from storage.935 * 936 * # <weight>937 * - `O(IK)` where `I` length of `keys` and `K` length of one key938 * - `I` storage deletions.939 * - Base Weight: .378 * i µs940 * - Writes: Number of items941 * # </weight>942 **/943 killStorage: AugmentedSubmittable<(keys: Vec<Bytes> | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Bytes>]>;944 /**945 * Make some on-chain remark.946 * 947 * # <weight>948 * - `O(1)`949 * # </weight>950 **/951 remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;952 /**953 * Make some on-chain remark and emit event.954 * 955 * # <weight>956 * - `O(b)` where b is the length of the remark.957 * - 1 event.958 * # </weight>959 **/960 remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;961 /**962 * Set the new changes trie configuration.963 * 964 * # <weight>965 * - `O(1)`966 * - 1 storage write or delete (codec `O(1)`).967 * - 1 call to `deposit_log`: Uses `append` API, so O(1)968 * - Base Weight: 7.218 µs969 * - DB Weight:970 * - Writes: Changes Trie, System Digest971 * # </weight>972 **/973 setChangesTrieConfig: AugmentedSubmittable<(changesTrieConfig: Option<SpCoreChangesTrieChangesTrieConfiguration> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<SpCoreChangesTrieChangesTrieConfiguration>]>;974 /**975 * Set the new runtime code.976 * 977 * # <weight>978 * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`979 * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is980 * expensive).981 * - 1 storage write (codec `O(C)`).982 * - 1 digest item.983 * - 1 event.984 * The weight of this function is dependent on the runtime, but generally this is very985 * expensive. We will treat this as a full block.986 * # </weight>987 **/988 setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;989 /**990 * Set the new runtime code without doing any checks of the given `code`.991 * 992 * # <weight>993 * - `O(C)` where `C` length of `code`994 * - 1 storage write (codec `O(C)`).995 * - 1 digest item.996 * - 1 event.997 * The weight of this function is dependent on the runtime. We will treat this as a full998 * block. # </weight>999 **/1000 setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;1001 /**1002 * Set the number of pages in the WebAssembly environment's heap.1003 * 1004 * # <weight>1005 * - `O(1)`1006 * - 1 storage write.1007 * - Base Weight: 1.405 µs1008 * - 1 write to HEAP_PAGES1009 * - 1 digest item1010 * # </weight>1011 **/1012 setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;1013 /**1014 * Set some items of storage.1015 * 1016 * # <weight>1017 * - `O(I)` where `I` length of `items`1018 * - `I` storage writes (`O(1)`).1019 * - Base Weight: 0.568 * i µs1020 * - Writes: Number of items1021 * # </weight>1022 **/1023 setStorage: AugmentedSubmittable<(items: Vec<ITuple<[Bytes, Bytes]>> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic<ApiType>, [Vec<ITuple<[Bytes, Bytes]>>]>;1024 /**1025 * Generic tx1026 **/1027 [key: string]: SubmittableExtrinsicFunction<ApiType>;1028 };1029 timestamp: {1030 /**1031 * Set the current time.1032 * 1033 * This call should be invoked exactly once per block. It will panic at the finalization1034 * phase, if this call hasn't been invoked by that time.1035 * 1036 * The timestamp should be greater than the previous one by the amount specified by1037 * `MinimumPeriod`.1038 * 1039 * The dispatch origin for this call must be `Inherent`.1040 * 1041 * # <weight>1042 * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)1043 * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in1044 * `on_finalize`)1045 * - 1 event handler `on_timestamp_set`. Must be `O(1)`.1046 * # </weight>1047 **/1048 set: AugmentedSubmittable<(now: Compact<u64> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u64>]>;1049 /**1050 * Generic tx1051 **/1052 [key: string]: SubmittableExtrinsicFunction<ApiType>;1053 };1054 treasury: {1055 /**1056 * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary1057 * and the original deposit will be returned.1058 * 1059 * May only be called from `T::ApproveOrigin`.1060 * 1061 * # <weight>1062 * - Complexity: O(1).1063 * - DbReads: `Proposals`, `Approvals`1064 * - DbWrite: `Approvals`1065 * # </weight>1066 **/1067 approveProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1068 /**1069 * Put forward a suggestion for spending. A deposit proportional to the value1070 * is reserved and slashed if the proposal is rejected. It is returned once the1071 * proposal is awarded.1072 * 1073 * # <weight>1074 * - Complexity: O(1)1075 * - DbReads: `ProposalCount`, `origin account`1076 * - DbWrites: `ProposalCount`, `Proposals`, `origin account`1077 * # </weight>1078 **/1079 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]>;1080 /**1081 * Reject a proposed spend. The original deposit will be slashed.1082 * 1083 * May only be called from `T::RejectOrigin`.1084 * 1085 * # <weight>1086 * - Complexity: O(1)1087 * - DbReads: `Proposals`, `rejected proposer account`1088 * - DbWrites: `Proposals`, `rejected proposer account`1089 * # </weight>1090 **/1091 rejectProposal: AugmentedSubmittable<(proposalId: Compact<u32> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<u32>]>;1092 /**1093 * Generic tx1094 **/1095 [key: string]: SubmittableExtrinsicFunction<ApiType>;1096 };1097 vesting: {1098 /**1099 * Force a vested transfer.1100 * 1101 * The dispatch origin for this call must be _Root_.1102 * 1103 * - `source`: The account whose funds should be transferred.1104 * - `target`: The account that should be transferred the vested funds.1105 * - `schedule`: The vesting schedule attached to the transfer.1106 * 1107 * Emits `VestingCreated`.1108 * 1109 * NOTE: This will unlock all schedules through the current block.1110 * 1111 * # <weight>1112 * - `O(1)`.1113 * - DbWeight: 4 Reads, 4 Writes1114 * - Reads: Vesting Storage, Balances Locks, Target Account, Source Account1115 * - Writes: Vesting Storage, Balances Locks, Target Account, Source Account1116 * # </weight>1117 **/1118 forceVestedTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: PalletVestingVestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, MultiAddress, PalletVestingVestingInfo]>;1119 /**1120 * Merge two vesting schedules together, creating a new vesting schedule that unlocks over1121 * the highest possible start and end blocks. If both schedules have already started the1122 * current block will be used as the schedule start; with the caveat that if one schedule1123 * is finished by the current block, the other will be treated as the new merged schedule,1124 * unmodified.1125 * 1126 * NOTE: If `schedule1_index == schedule2_index` this is a no-op.1127 * NOTE: This will unlock all schedules through the current block prior to merging.1128 * NOTE: If both schedules have ended by the current block, no new schedule will be created1129 * and both will be removed.1130 * 1131 * Merged schedule attributes:1132 * - `starting_block`: `MAX(schedule1.starting_block, scheduled2.starting_block,1133 * current_block)`.1134 * - `ending_block`: `MAX(schedule1.ending_block, schedule2.ending_block)`.1135 * - `locked`: `schedule1.locked_at(current_block) + schedule2.locked_at(current_block)`.1136 * 1137 * The dispatch origin for this call must be _Signed_.1138 * 1139 * - `schedule1_index`: index of the first schedule to merge.1140 * - `schedule2_index`: index of the second schedule to merge.1141 **/1142 mergeSchedules: AugmentedSubmittable<(schedule1Index: u32 | AnyNumber | Uint8Array, schedule2Index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u32, u32]>;1143 /**1144 * Unlock any vested funds of the sender account.1145 * 1146 * The dispatch origin for this call must be _Signed_ and the sender must have funds still1147 * locked under this pallet.1148 * 1149 * Emits either `VestingCompleted` or `VestingUpdated`.1150 * 1151 * # <weight>1152 * - `O(1)`.1153 * - DbWeight: 2 Reads, 2 Writes1154 * - Reads: Vesting Storage, Balances Locks, [Sender Account]1155 * - Writes: Vesting Storage, Balances Locks, [Sender Account]1156 * # </weight>1157 **/1158 vest: AugmentedSubmittable<() => SubmittableExtrinsic<ApiType>, []>;1159 /**1160 * Create a vested transfer.1161 * 1162 * The dispatch origin for this call must be _Signed_.1163 * 1164 * - `target`: The account receiving the vested funds.1165 * - `schedule`: The vesting schedule attached to the transfer.1166 * 1167 * Emits `VestingCreated`.1168 * 1169 * NOTE: This will unlock all schedules through the current block.1170 * 1171 * # <weight>1172 * - `O(1)`.1173 * - DbWeight: 3 Reads, 3 Writes1174 * - Reads: Vesting Storage, Balances Locks, Target Account, [Sender Account]1175 * - Writes: Vesting Storage, Balances Locks, Target Account, [Sender Account]1176 * # </weight>1177 **/1178 vestedTransfer: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: PalletVestingVestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress, PalletVestingVestingInfo]>;1179 /**1180 * Unlock any vested funds of a `target` account.1181 * 1182 * The dispatch origin for this call must be _Signed_.1183 * 1184 * - `target`: The account whose vested funds should be unlocked. Must have funds still1185 * locked under this pallet.1186 * 1187 * Emits either `VestingCompleted` or `VestingUpdated`.1188 * 1189 * # <weight>1190 * - `O(1)`.1191 * - DbWeight: 3 Reads, 3 Writes1192 * - Reads: Vesting Storage, Balances Locks, Target Account1193 * - Writes: Vesting Storage, Balances Locks, Target Account1194 * # </weight>1195 **/1196 vestOther: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [MultiAddress]>;1197 /**1198 * Generic tx1199 **/1200 [key: string]: SubmittableExtrinsicFunction<ApiType>;1201 };1202 xcmpQueue: {1203 /**1204 * Generic tx1205 **/1206 [key: string]: SubmittableExtrinsicFunction<ApiType>;1207 };1208 }12091210 export interface SubmittableExtrinsics<ApiType extends ApiTypes> extends AugmentedSubmittables<ApiType> {1211 (extrinsic: Call | Extrinsic | Uint8Array | string): SubmittableExtrinsic<ApiType>;1212 [key: string]: SubmittableModuleExtrinsics<ApiType>;1213 }1214}difftreelog
source
tests/src/interfaces/augment-api-tx.ts58.4 KiBsourcehistory