import { StorageDescriptor, PlainDescriptor, TxDescriptor, RuntimeDescriptor, Enum, ApisFromDef, QueryFromPalletsDef, TxFromPalletsDef, EventsFromPalletsDef, ErrorsFromPalletsDef, ConstFromPalletsDef, ViewFnsFromPalletsDef, SS58String, FixedSizeBinary, Binary, FixedSizeArray } from "polkadot-api"; import { I5sesotjlssv2d, Iffmde3ekjedi9, I4mddgoa69c0a2, Ibn2t84v0qbqml, I95g6i7ilua7lq, Ieniouoqkq4icf, Phase, Ibgl04rn6nbfm6, I4q39t5hn830vp, I1v7jbnil3tjns, I8jgj1nhcr2dg8, Ifn6q3equiq9qi, Ia3sb0vgvovhtg, Iav8k1edbj86k7, Itom7fk49o0c9, I4i91h98n3cv1b, I4iumukclgj8ej, Iqnbvitf7a7l3, I48i407regf59r, I6r5cbv8ttrb09, I1q8tnt1cluu5j, I8ds64oj6581v0, Ia7pdug7cdsg8g, Iafsev9pf8ur2h, I9bin2jc70qt6q, TransactionPaymentReleases, I52552vmt51a1m, Icd998p53cb80u, Ianratlvp36bb8, Ia2lhg7l2hilo3, Ifi4da1gej1fri, Ifvgo9568rpmqc, I82jm9g7pufuel, Ic5m5lp1oioo8r, I6cs1itejju2vv, Icgljjb6j82uhn, Ib77b0fp1a6mjr, I5g2vv0ckl2m8b, Ifup3lg9ro8a0f, I5qfubnuvrnqn6, I8t3u2dv73ahbd, I7vlvrrl2pnbgk, Ie0rpl5bahldfk, XcmPalletVersionMigrationStage, I7e5oaj2qi4kl1, Ie849h3gncgvok, Iat62vud7hlod2, Ict03eedr8de9s, Ibkm2gcn4pji30, XcmVersionedLocation, Idh2ug6ou4a8og, Iejeo53sea6n4q, I53esa2ms463bk, Ib4jhb8tt3uung, In7a38730s6qs, Ibtil0ss5munbk, I9s0ave7t0vnrk, I4fo08joqmcqnm, XcmV5Junctions, Iasb8k6ash5mjn, I8ofcg5rbj0g2c, I4adgbll7gku4i, I6pjjpfvhvcfru, I9pj91mj79qekl, I39uah9nss64h9, Ik64dknsq7k08, Ib51vk42m1po4n, Ial23jn8hp0aen, Ifpj261e8s63m3, Idcr6u6361oad9, I4m23d919gtr5d, I7esubsve8jvbp, I69p6pkv67dei3, I13j8trtusi7dq, I74eam70qc8398, I4ktuaksf5i1gk, I9bqtpv2ii35mp, I9j7pagd6d4bda, I2h9pmio37r7fb, Ibmr18suc9ikh9, I9iq22t0burs89, I5u8olqbbvfnvf, I5utcetro501ir, Itrlf5b2o2l8q, Icegg8a2cqf1gu, I4vj3ndsquheo1, I7h5kud22qmfsg, I2i8iea6e4ne1j, I4jotama61aldv, I4cbvqmqadhrea, I3rfugj0vt1ug5, Ifccifqltb5obi, Iadtsfv699cq8b, Ialpmgmhr3gk5r, I3sdol54kg5jaq, I8fougodaj6di6, I81vt5eq60l4b6, I3vh014cqgmrfd, Ia5cotcvi888ln, I21jsa919m88fd, Iegif7m3upfe1k, I9kt8c221c83ln, Ic76kfh5ebqkpl, Icscpmubum33bq, I21d2olof7eb60, Ibgm4rnf22lal1, Ie68np0vpihith, I9bnv6lu0crf1q, Iauhjqifrdklq7, Ie1uso9m8rt5cf, I40pqum1mu8qg3, I1r4c2ghbtvjuc, I2hedg0a6u185f, I8k3rnvpeeh4hv, I550f2tngqhbp1, Ia82mnkmeo2rhc, Icsa46bnbuohqc, Icbccs0ug47ilf, I855j4i3kr8ko1, I67n6mbhp91nlg, Idd7hd99u0ho0n, Iafscmv8tjf0ou, I100l07kaehdlp, I6gnbnvip5vvdi, I368e0tjmrcvlt, I6akqkga7li13u, I133qpg6ru2jqi, I3bp93psani87u, Icv68aq8841478, Ic262ibdoec56a, Iflcfm9b6nlmdd, Ijrsf4mnp3eka, Id5fm4p8lj5qgi, I8tjvj9uq4b7hi, I3qt1hgg4djhgb, I4fooe9dun9o0t, I8mvf14goplnni, Ie09mpthond7d6, I1ispultrc7caq, Iph9c4rn81ub2, Ier2cke86dqbr2, Ibi0s841005et5, I395h9meqpi2hf, I66jdpl6lile9j, I39t01nnod9109, I6v8sm60vvkmk7, I1qmtmbe5so8r3, Ih99m6ehpcar7, Idgorhsbgdq2ap, I9ubb2kqevnu6t, I2hq50pu2kdjpo, I9acqruh7322g2, I137t1cld92pod, I61d51nv4cou88, If8u5kl4h8070m, Ibmuil6p3vl83l, I7lul91g50ae87, Icl7nl1rfeog3i, Iasr6pj6shs0fl, I2uqmls7kcdnii, Idg69klialbkb8, I7r6b7145022pp, I30pg328m00nr3, Icmrn7bogp28cs, I7m9b5plj4h5ot, I9onhk772nfs4f, I3l6bnksrmt56r, Idh09k0l2pmdcg, I7uoiphbm0tj4r, I512p1n7qt24l8, I6s1nbislhk619, I3gghqnh2mj0is, I6iv852roh6t3h, I9oc2o6itbiopq, Ibslgga81p36aa, I1rvj4ubaplho0, Ia3uu7lqcc1q1i, I7crucfnonitkn, I7tmrp94r9sq4n, I4kigljjkan2n6, I5rtkmhm2dng4u, I5r8t4iaend96p, Iaqet9jc3ihboe, Ic952bubvq4k7d, I2v50gu3s1aqk6, Iabpgqcjikia83, Ieeb2u9t56qdcr, If7uv525tdvv7a, I2an1fs2eiebjp, TransactionValidityTransactionSource, I9ask1o4tfvcvs, I4ph3d1eepnmr1, Icerf8h8pdu8ss, I6spmpef2c7svf, Iei2mvq0mjvt81, Icd41grt22tk3v, Iftvbctbo05fu4, XcmVersionedXcm, Ic0c3req3mlc1l, XcmVersionedAssetId, I7ocn4njqde3v5, Iek7ha36da9mf5, I9cqlcs1cfiqgk, Ia0qb5p8rcp095, I7f06kkvfvbvn3, Ieh6nis3hdbtgi, XcmVersionedAsset, Icujp6hmv35vbn, I4tjame31218k9, I5gif8vomct5i8, Ic1d4u2opv3fst, Ie9sr1iqcg3cgm, I1mqgk2tmnn9i2, I6lr8sctk0bi4e, Id3cclc8rha27v } from "./common-types"; type AnonymousEnum = T & { __anonymous: true; }; type MyTuple = [T, ...T[]]; type SeparateUndefined = undefined extends T ? undefined | Exclude : T; type Anonymize = SeparateUndefined ? number extends L ? Binary : FixedSizeBinary : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum ? T : T extends AnonymousEnum ? Enum : T extends MyTuple ? { [K in keyof T]: T[K]; } : T extends [] ? [] : T extends FixedSizeArray ? number extends L ? Array : FixedSizeArray : { [K in keyof T & string]: T[K]; }>; type IStorage = { System: { /** * The full account information for a particular account ID. */ Account: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; /** * Total extrinsics count for the current block. */ ExtrinsicCount: StorageDescriptor<[], number, true, never>; /** * Whether all inherents have been applied. */ InherentsApplied: StorageDescriptor<[], boolean, false, never>; /** * The current weight for the block. */ BlockWeight: StorageDescriptor<[], Anonymize, false, never>; /** * Total size (in bytes) of the current block. * * Tracks the size of the header and all extrinsics. */ BlockSize: StorageDescriptor<[], number, true, never>; /** * Map of block numbers to block hashes. */ BlockHash: StorageDescriptor<[Key: number], FixedSizeBinary<32>, false, never>; /** * Extrinsics data for the current block (maps an extrinsic's index to its data). */ ExtrinsicData: StorageDescriptor<[Key: number], Binary, false, never>; /** * The current block number being processed. Set by `execute_block`. */ Number: StorageDescriptor<[], number, false, never>; /** * Hash of the previous block. */ ParentHash: StorageDescriptor<[], FixedSizeBinary<32>, false, never>; /** * Digest of the current block, also part of the block header. */ Digest: StorageDescriptor<[], Anonymize, false, never>; /** * Events deposited for the current block. * * NOTE: The item is unbound and should therefore never be read on chain. * It could otherwise inflate the PoV size of a block. * * Events have a large in-memory size. Box the events to not go out-of-memory * just in case someone still reads them from within the runtime. */ Events: StorageDescriptor<[], Anonymize, false, never>; /** * The number of events in the `Events` list. */ EventCount: StorageDescriptor<[], number, false, never>; /** * Mapping between a topic (represented by T::Hash) and a vector of indexes * of events in the `>` list. * * All topic vectors have deterministic storage locations depending on the topic. This * allows light-clients to leverage the changes trie storage tracking mechanism and * in case of changes fetch the list of events of interest. * * The value has the type `(BlockNumberFor, EventIndex)` because if we used only just * the `EventIndex` then in case if the topic has the same contents on the next block * no notification will be triggered thus the event might be lost. */ EventTopics: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize, false, never>; /** * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened. */ LastRuntimeUpgrade: StorageDescriptor<[], Anonymize, true, never>; /** * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not. */ UpgradedToU32RefCount: StorageDescriptor<[], boolean, false, never>; /** * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False * (default) if not. */ UpgradedToTripleRefCount: StorageDescriptor<[], boolean, false, never>; /** * The execution phase of the block. */ ExecutionPhase: StorageDescriptor<[], Phase, true, never>; /** * `Some` if a code upgrade has been authorized. */ AuthorizedUpgrade: StorageDescriptor<[], Anonymize, true, never>; /** * The weight reclaimed for the extrinsic. * * This information is available until the end of the extrinsic execution. * More precisely this information is removed in `note_applied_extrinsic`. * * Logic doing some post dispatch weight reduction must update this storage to avoid duplicate * reduction. */ ExtrinsicWeightReclaimed: StorageDescriptor<[], Anonymize, false, never>; }; ParachainSystem: { /** * Latest included block descendants the runtime accepted. In other words, these are * ancestors of the currently executing block which have not been included in the observed * relay-chain state. * * The segment length is limited by the capacity returned from the [`ConsensusHook`] configured * in the pallet. */ UnincludedSegment: StorageDescriptor<[], Anonymize, false, never>; /** * Storage field that keeps track of bandwidth used by the unincluded segment along with the * latest HRMP watermark. Used for limiting the acceptance of new blocks with * respect to relay chain constraints. */ AggregatedUnincludedSegment: StorageDescriptor<[], Anonymize, true, never>; /** * In case of a scheduled upgrade, this storage field contains the validation code to be * applied. * * As soon as the relay chain gives us the go-ahead signal, we will overwrite the * [`:code`][sp_core::storage::well_known_keys::CODE] which will result the next block process * with the new validation code. This concludes the upgrade process. */ PendingValidationCode: StorageDescriptor<[], Binary, false, never>; /** * Validation code that is set by the parachain and is to be communicated to collator and * consequently the relay-chain. * * This will be cleared in `on_initialize` of each new block if no other pallet already set * the value. */ NewValidationCode: StorageDescriptor<[], Binary, true, never>; /** * The [`PersistedValidationData`] set for this block. * * This value is expected to be set only once by the [`Pallet::set_validation_data`] inherent. */ ValidationData: StorageDescriptor<[], Anonymize, true, never>; /** * Were the validation data set to notify the relay chain? */ DidSetValidationCode: StorageDescriptor<[], boolean, false, never>; /** * The relay chain block number associated with the last parachain block. * * This is updated in `on_finalize`. */ LastRelayChainBlockNumber: StorageDescriptor<[], number, false, never>; /** * An option which indicates if the relay-chain restricts signalling a validation code upgrade. * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced * candidate will be invalid. * * This storage item is a mirror of the corresponding value for the current parachain from the * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is * set after the inherent. */ UpgradeRestrictionSignal: StorageDescriptor<[], Anonymize, false, never>; /** * Optional upgrade go-ahead signal from the relay-chain. * * This storage item is a mirror of the corresponding value for the current parachain from the * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is * set after the inherent. */ UpgradeGoAhead: StorageDescriptor<[], Anonymize, false, never>; /** * The state proof for the last relay parent block. * * This field is meant to be updated each block with the validation data inherent. Therefore, * before processing of the inherent, e.g. in `on_initialize` this data may be stale. * * This data is also absent from the genesis. */ RelayStateProof: StorageDescriptor<[], Anonymize, true, never>; /** * The snapshot of some state related to messaging relevant to the current parachain as per * the relay parent. * * This field is meant to be updated each block with the validation data inherent. Therefore, * before processing of the inherent, e.g. in `on_initialize` this data may be stale. * * This data is also absent from the genesis. */ RelevantMessagingState: StorageDescriptor<[], Anonymize, true, never>; /** * The parachain host configuration that was obtained from the relay parent. * * This field is meant to be updated each block with the validation data inherent. Therefore, * before processing of the inherent, e.g. in `on_initialize` this data may be stale. * * This data is also absent from the genesis. */ HostConfiguration: StorageDescriptor<[], Anonymize, true, never>; /** * The last downward message queue chain head we have observed. * * This value is loaded before and saved after processing inbound downward messages carried * by the system inherent. */ LastDmqMqcHead: StorageDescriptor<[], FixedSizeBinary<32>, false, never>; /** * The message queue chain heads we have observed per each channel incoming channel. * * This value is loaded before and saved after processing inbound downward messages carried * by the system inherent. */ LastHrmpMqcHeads: StorageDescriptor<[], Anonymize, false, never>; /** * Number of downward messages processed in a block. * * This will be cleared in `on_initialize` of each new block. */ ProcessedDownwardMessages: StorageDescriptor<[], number, false, never>; /** * The last processed downward message. * * We need to keep track of this to filter the messages that have been already processed. */ LastProcessedDownwardMessage: StorageDescriptor<[], Anonymize, true, never>; /** * HRMP watermark that was set in a block. */ HrmpWatermark: StorageDescriptor<[], number, false, never>; /** * The last processed HRMP message. * * We need to keep track of this to filter the messages that have been already processed. */ LastProcessedHrmpMessage: StorageDescriptor<[], Anonymize, true, never>; /** * HRMP messages that were sent in a block. * * This will be cleared in `on_initialize` of each new block. */ HrmpOutboundMessages: StorageDescriptor<[], Anonymize, false, never>; /** * Upward messages that were sent in a block. * * This will be cleared in `on_initialize` for each new block. */ UpwardMessages: StorageDescriptor<[], Anonymize, false, never>; /** * Upward messages that are still pending and not yet sent to the relay chain. */ PendingUpwardMessages: StorageDescriptor<[], Anonymize, false, never>; /** * Upward signals that are still pending and not yet sent to the relay chain. * * This will be cleared in `on_finalize` for each block. */ PendingUpwardSignals: StorageDescriptor<[], Anonymize, false, never>; /** * The factor to multiply the base delivery fee by for UMP. */ UpwardDeliveryFeeFactor: StorageDescriptor<[], bigint, false, never>; /** * The number of HRMP messages we observed in `on_initialize` and thus used that number for * announcing the weight of `on_initialize` and `on_finalize`. */ AnnouncedHrmpMessagesPerCandidate: StorageDescriptor<[], number, false, never>; /** * The weight we reserve at the beginning of the block for processing XCMP messages. This * overrides the amount set in the Config trait. */ ReservedXcmpWeightOverride: StorageDescriptor<[], Anonymize, true, never>; /** * The weight we reserve at the beginning of the block for processing DMP messages. This * overrides the amount set in the Config trait. */ ReservedDmpWeightOverride: StorageDescriptor<[], Anonymize, true, never>; /** * A custom head data that should be returned as result of `validate_block`. * * See `Pallet::set_custom_validation_head_data` for more information. */ CustomValidationHeadData: StorageDescriptor<[], Binary, true, never>; }; Timestamp: { /** * The current time for the current block. */ Now: StorageDescriptor<[], bigint, false, never>; /** * Whether the timestamp has been updated in this block. * * This value is updated to `true` upon successful submission of a timestamp by a node. * It is then checked at the end of each block execution in the `on_finalize` hook. */ DidUpdate: StorageDescriptor<[], boolean, false, never>; }; ParachainInfo: { /** */ ParachainId: StorageDescriptor<[], number, false, never>; }; Balances: { /** * The total units issued in the system. */ TotalIssuance: StorageDescriptor<[], bigint, false, never>; /** * The total units of outstanding deactivated balance in the system. */ InactiveIssuance: StorageDescriptor<[], bigint, false, never>; /** * The Balances pallet example of storing the balance of an account. * * # Example * * ```nocompile * impl pallet_balances::Config for Runtime { * type AccountStore = StorageMapShim, frame_system::Provider, AccountId, Self::AccountData> * } * ``` * * You can also store the balance of an account in the `System` pallet. * * # Example * * ```nocompile * impl pallet_balances::Config for Runtime { * type AccountStore = System * } * ``` * * But this comes with tradeoffs, storing account balances in the system pallet stores * `frame_system` data alongside the account data contrary to storing account balances in the * `Balances` pallet, which uses a `StorageMap` to store balances data only. * NOTE: This is only used in the case that this pallet is used to store balances. */ Account: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; /** * Any liquidity locks on some account balances. * NOTE: Should only be accessed when setting, changing and freeing a lock. * * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/` */ Locks: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; /** * Named reserves on some account balances. * * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/` */ Reserves: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; /** * Holds on account balances. */ Holds: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; /** * Freeze locks on account balances. */ Freezes: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; }; TransactionPayment: { /** */ NextFeeMultiplier: StorageDescriptor<[], bigint, false, never>; /** */ StorageVersion: StorageDescriptor<[], TransactionPaymentReleases, false, never>; /** * The `OnChargeTransaction` stores the withdrawn tx fee here. * * Use `withdraw_txfee` and `remaining_txfee` to access from outside the crate. */ TxPaymentCredit: StorageDescriptor<[], bigint, true, never>; }; TransactionStorage: { /** * Authorizations, keyed by scope. */ Authorizations: StorageDescriptor<[Key: Anonymize], Anonymize, true, never>; /** * Collection of transaction metadata by block number. */ Transactions: StorageDescriptor<[Key: number], Anonymize, true, never>; /** * Storage fee per byte. */ ByteFee: StorageDescriptor<[], bigint, true, never>; /** * Storage fee per transaction. */ EntryFee: StorageDescriptor<[], bigint, true, never>; /** * Number of blocks for which stored data must be retained. * * Data older than `RetentionPeriod` blocks is eligible for removal unless it * has been explicitly renewed. Validators are required to prove possession of * data corresponding to block `N - RetentionPeriod` when producing block `N`. */ RetentionPeriod: StorageDescriptor<[], number, false, never>; /** */ BlockTransactions: StorageDescriptor<[], Anonymize, false, never>; /** * Was the proof checked in this block? */ ProofChecked: StorageDescriptor<[], boolean, false, never>; }; Authorship: { /** * Author of current block. */ Author: StorageDescriptor<[], SS58String, true, never>; }; CollatorSelection: { /** * The invulnerable, permissioned collators. This list must be sorted. */ Invulnerables: StorageDescriptor<[], Anonymize, false, never>; /** * The (community, limited) collation candidates. `Candidates` and `Invulnerables` should be * mutually exclusive. * * This list is sorted in ascending order by deposit and when the deposits are equal, the least * recently updated is considered greater. */ CandidateList: StorageDescriptor<[], Anonymize, false, never>; /** * Last block authored by collator. */ LastAuthoredBlock: StorageDescriptor<[Key: SS58String], number, false, never>; /** * Desired number of candidates. * * This should ideally always be less than [`Config::MaxCandidates`] for weights to be correct. */ DesiredCandidates: StorageDescriptor<[], number, false, never>; /** * Fixed amount to deposit to become a collator. * * When a collator calls `leave_intent` they immediately receive the deposit back. */ CandidacyBond: StorageDescriptor<[], bigint, false, never>; }; Session: { /** * The current set of validators. */ Validators: StorageDescriptor<[], Anonymize, false, never>; /** * Current index of the session. */ CurrentIndex: StorageDescriptor<[], number, false, never>; /** * True if the underlying economic identities or weighting behind the validators * has changed in the queued validator set. */ QueuedChanged: StorageDescriptor<[], boolean, false, never>; /** * The queued keys for the next session. When the next session begins, these keys * will be used to determine the validator's session keys. */ QueuedKeys: StorageDescriptor<[], Anonymize, false, never>; /** * Indices of disabled validators. * * The vec is always kept sorted so that we can find whether a given validator is * disabled using binary search. It gets cleared when `on_session_ending` returns * a new set of identities. */ DisabledValidators: StorageDescriptor<[], Anonymize, false, never>; /** * The next session keys for a validator. */ NextKeys: StorageDescriptor<[Key: SS58String], FixedSizeBinary<32>, true, never>; /** * The owner of a key. The key is the `KeyTypeId` + the encoded key. */ KeyOwner: StorageDescriptor<[Key: Anonymize], SS58String, true, never>; /** * Accounts whose keys were set via `SessionInterface` (external path) without * incrementing the consumer reference or placing a key deposit. `do_purge_keys` * only decrements consumers for accounts that were registered through the local * session pallet. */ ExternallySetKeys: StorageDescriptor<[Key: SS58String], null, true, never>; }; Aura: { /** * The current authority set. */ Authorities: StorageDescriptor<[], Anonymize, false, never>; /** * The current slot of this block. * * This will be set in `on_initialize`. */ CurrentSlot: StorageDescriptor<[], bigint, false, never>; }; AuraExt: { /** * Serves as cache for the authorities. * * The authorities in AuRa are overwritten in `on_initialize` when we switch to a new session, * but we require the old authorities to verify the seal when validating a PoV. This will * always be updated to the latest AuRa authorities in `on_finalize`. */ Authorities: StorageDescriptor<[], Anonymize, false, never>; /** * Current relay chain slot paired with a number of authored blocks. * * This is updated in [`FixedVelocityConsensusHook::on_state_proof`] with the current relay * chain slot as provided by the relay chain state proof. */ RelaySlotInfo: StorageDescriptor<[], Anonymize, true, never>; }; XcmpQueue: { /** * The suspended inbound XCMP channels. All others are not suspended. * * This is a `StorageValue` instead of a `StorageMap` since we expect multiple reads per block * to different keys with a one byte payload. The access to `BoundedBTreeSet` will be cached * within the block and therefore only included once in the proof size. * * NOTE: The PoV benchmarking cannot know this and will over-estimate, but the actual proof * will be smaller. */ InboundXcmpSuspended: StorageDescriptor<[], Anonymize, false, never>; /** * The non-empty XCMP channels in order of becoming non-empty, and the index of the first * and last outbound message. If the two indices are equal, then it indicates an empty * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in * case of the need to send a high-priority signal message this block. * The bool is true if there is a signal message waiting to be sent. */ OutboundXcmpStatus: StorageDescriptor<[], Anonymize, false, never>; /** * The messages outbound in a given XCMP channel. */ OutboundXcmpMessages: StorageDescriptor, Binary, false, never>; /** * Any signal messages waiting to be sent. */ SignalMessages: StorageDescriptor<[Key: number], Binary, false, never>; /** * The configuration which controls the dynamics of the outbound queue. */ QueueConfig: StorageDescriptor<[], Anonymize, false, never>; /** * Whether or not the XCMP queue is suspended from executing incoming XCMs or not. */ QueueSuspended: StorageDescriptor<[], boolean, false, never>; /** * The factor to multiply the base delivery fee by. */ DeliveryFeeFactor: StorageDescriptor<[Key: number], bigint, false, never>; }; PolkadotXcm: { /** * The latest available query index. */ QueryCounter: StorageDescriptor<[], bigint, false, never>; /** * The ongoing queries. */ Queries: StorageDescriptor<[Key: bigint], Anonymize, true, never>; /** * The existing asset traps. * * Key is the blake2 256 hash of (origin, versioned `Assets`) pair. Value is the number of * times this pair has been trapped (usually just 1 if it exists at all). */ AssetTraps: StorageDescriptor<[Key: FixedSizeBinary<32>], number, false, never>; /** * Default version to encode XCM when latest version of destination is unknown. If `None`, * then the destinations whose XCM version is unknown are considered unreachable. */ SafeXcmVersion: StorageDescriptor<[], number, true, never>; /** * The Latest versions that we know various locations support. */ SupportedVersion: StorageDescriptor, number, true, never>; /** * All locations that we have requested version notifications from. */ VersionNotifiers: StorageDescriptor, bigint, true, never>; /** * The target locations that are subscribed to our version changes, as well as the most recent * of our versions we informed them of. */ VersionNotifyTargets: StorageDescriptor, Anonymize, true, never>; /** * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and * the `u32` counter is the number of times that a send to the destination has been attempted, * which is used as a prioritization. */ VersionDiscoveryQueue: StorageDescriptor<[], Anonymize, false, never>; /** * The current migration's stage, if any. */ CurrentMigration: StorageDescriptor<[], XcmPalletVersionMigrationStage, true, never>; /** * Fungible assets which we know are locked on a remote chain. */ RemoteLockedFungibles: StorageDescriptor, Anonymize, true, never>; /** * Fungible assets which we know are locked on this chain. */ LockedFungibles: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; /** * Global suspension state of the XCM executor. */ XcmExecutionSuspended: StorageDescriptor<[], boolean, false, never>; /** * Whether or not incoming XCMs (both executed locally and received) should be recorded. * Only one XCM program will be recorded at a time. * This is meant to be used in runtime APIs, and it's advised it stays false * for all other use cases, so as to not degrade regular performance. * * Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`] * implementation in the XCM executor configuration. */ ShouldRecordXcm: StorageDescriptor<[], boolean, false, never>; /** * If [`ShouldRecordXcm`] is set to true, then the last XCM program executed locally * will be stored here. * Runtime APIs can fetch the XCM that was executed by accessing this value. * * Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`] * implementation in the XCM executor configuration. */ RecordedXcm: StorageDescriptor<[], Anonymize, true, never>; /** * Map of authorized aliasers of local origins. Each local location can authorize a list of * other locations to alias into it. Each aliaser is only valid until its inner `expiry` * block number. */ AuthorizedAliases: StorageDescriptor<[Key: XcmVersionedLocation], Anonymize, true, never>; }; MessageQueue: { /** * The index of the first and last (non-empty) pages. */ BookStateFor: StorageDescriptor<[Key: Anonymize], Anonymize, false, never>; /** * The origin at which we should begin servicing. */ ServiceHead: StorageDescriptor<[], Anonymize, true, never>; /** * The map of page indices to pages. */ Pages: StorageDescriptor, Anonymize, true, never>; }; Sudo: { /** * The `AccountId` of the sudo key. */ Key: StorageDescriptor<[], SS58String, true, never>; }; }; type ICalls = { System: { /** * Make some on-chain remark. * * Can be executed by every `origin`. */ remark: TxDescriptor>; /** * Set the number of pages in the WebAssembly environment's heap. */ set_heap_pages: TxDescriptor>; /** * Set the new runtime code. */ set_code: TxDescriptor>; /** * Set the new runtime code without doing any checks of the given `code`. * * Note that runtime upgrades will not run if this is called with a not-increasing spec * version! */ set_code_without_checks: TxDescriptor>; /** * Set some items of storage. */ set_storage: TxDescriptor>; /** * Kill some items from storage. */ kill_storage: TxDescriptor>; /** * Kill all storage items with a key that starts with the given prefix. * * **NOTE:** We rely on the Root origin to provide us the number of subkeys under * the prefix we are removing to accurately calculate the weight of this function. */ kill_prefix: TxDescriptor>; /** * Make some on-chain remark and emit event. */ remark_with_event: TxDescriptor>; /** * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied * later. * * This call requires Root origin. */ authorize_upgrade: TxDescriptor>; /** * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied * later. * * WARNING: This authorizes an upgrade that will take place without any safety checks, for * example that the spec name remains the same and that the version number increases. Not * recommended for normal use. Use `authorize_upgrade` instead. * * This call requires Root origin. */ authorize_upgrade_without_checks: TxDescriptor>; /** * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized. * * If the authorization required a version check, this call will ensure the spec name * remains unchanged and that the spec version has increased. * * Depending on the runtime's `OnSetCode` configuration, this function may directly apply * the new `code` in the same block or attempt to schedule the upgrade. * * All origins are allowed. */ apply_authorized_upgrade: TxDescriptor>; }; ParachainSystem: { /** * Set the current validation data. * * This should be invoked exactly once per block. It will panic at the finalization * phase if the call was not invoked. * * The dispatch origin for this call must be `Inherent` * * As a side effect, this function upgrades the current validation function * if the appropriate time has come. */ set_validation_data: TxDescriptor>; /** */ sudo_send_upward_message: TxDescriptor>; }; Timestamp: { /** * Set the current time. * * This call should be invoked exactly once per block. It will panic at the finalization * phase, if this call hasn't been invoked by that time. * * The timestamp should be greater than the previous one by the amount specified by * [`Config::MinimumPeriod`]. * * The dispatch origin for this call must be _None_. * * This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be aware * that changing the complexity of this call could result exhausting the resources in a * block to execute any other calls. * * ## Complexity * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`) * - 1 storage read and 1 storage mutation (codec `O(1)` because of `DidUpdate::take` in * `on_finalize`) * - 1 event handler `on_timestamp_set`. Must be `O(1)`. */ set: TxDescriptor>; }; Utility: { /** * Send a batch of dispatch calls. * * May be called from any origin except `None`. * * - `calls`: The calls to be dispatched from the same origin. The number of call must not * exceed the constant: `batched_calls_limit` (available in constant metadata). * * If origin is root then the calls are dispatched without checking origin filter. (This * includes bypassing `frame_system::Config::BaseCallFilter`). * * ## Complexity * - O(C) where C is the number of calls to be batched. * * This will return `Ok` in all circumstances. To determine the success of the batch, an * event is deposited. If a call failed and the batch was interrupted, then the * `BatchInterrupted` event is deposited, along with the number of successful calls made * and the error of the failed call. If all were successful, then the `BatchCompleted` * event is deposited. */ batch: TxDescriptor>; /** * Send a call through an indexed pseudonym of the sender. * * Filter from origin are passed along. The call will be dispatched with an origin which * use the same filter as the origin of this call. * * NOTE: If you need to ensure that any account-based filtering is not honored (i.e. * because you expect `proxy` to have been used prior in the call stack and you do not want * the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1` * in the Multisig pallet instead. * * NOTE: Prior to version *12, this was called `as_limited_sub`. * * The dispatch origin for this call must be _Signed_. */ as_derivative: TxDescriptor>; /** * Send a batch of dispatch calls and atomically execute them. * The whole transaction will rollback and fail if any of the calls failed. * * May be called from any origin except `None`. * * - `calls`: The calls to be dispatched from the same origin. The number of call must not * exceed the constant: `batched_calls_limit` (available in constant metadata). * * If origin is root then the calls are dispatched without checking origin filter. (This * includes bypassing `frame_system::Config::BaseCallFilter`). * * ## Complexity * - O(C) where C is the number of calls to be batched. */ batch_all: TxDescriptor>; /** * Dispatches a function call with a provided origin. * * The dispatch origin for this call must be _Root_. * * ## Complexity * - O(1). */ dispatch_as: TxDescriptor>; /** * Send a batch of dispatch calls. * Unlike `batch`, it allows errors and won't interrupt. * * May be called from any origin except `None`. * * - `calls`: The calls to be dispatched from the same origin. The number of call must not * exceed the constant: `batched_calls_limit` (available in constant metadata). * * If origin is root then the calls are dispatch without checking origin filter. (This * includes bypassing `frame_system::Config::BaseCallFilter`). * * ## Complexity * - O(C) where C is the number of calls to be batched. */ force_batch: TxDescriptor>; /** * Dispatch a function call with a specified weight. * * This function does not check the weight of the call, and instead allows the * Root origin to specify the weight of the call. * * The dispatch origin for this call must be _Root_. */ with_weight: TxDescriptor>; /** * Dispatch a fallback call in the event the main call fails to execute. * May be called from any origin except `None`. * * This function first attempts to dispatch the `main` call. * If the `main` call fails, the `fallback` is attemted. * if the fallback is successfully dispatched, the weights of both calls * are accumulated and an event containing the main call error is deposited. * * In the event of a fallback failure the whole call fails * with the weights returned. * * - `main`: The main call to be dispatched. This is the primary action to execute. * - `fallback`: The fallback call to be dispatched in case the `main` call fails. * * ## Dispatch Logic * - If the origin is `root`, both the main and fallback calls are executed without * applying any origin filters. * - If the origin is not `root`, the origin filter is applied to both the `main` and * `fallback` calls. * * ## Use Case * - Some use cases might involve submitting a `batch` type call in either main, fallback * or both. */ if_else: TxDescriptor>; /** * Dispatches a function call with a provided origin. * * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call. * * The dispatch origin for this call must be _Root_. */ dispatch_as_fallible: TxDescriptor>; }; Balances: { /** * Transfer some liquid free balance to another account. * * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver. * If the sender's account is below the existential deposit as a result * of the transfer, the account will be reaped. * * The dispatch origin for this call must be `Signed` by the transactor. */ transfer_allow_death: TxDescriptor>; /** * Exactly as `transfer_allow_death`, except the origin must be root and the source account * may be specified. */ force_transfer: TxDescriptor>; /** * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not * kill the origin account. * * 99% of the time you want [`transfer_allow_death`] instead. * * [`transfer_allow_death`]: struct.Pallet.html#method.transfer */ transfer_keep_alive: TxDescriptor>; /** * Transfer the entire transferable balance from the caller account. * * NOTE: This function only attempts to transfer _transferable_ balances. This means that * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be * transferred by this function. To ensure that this function results in a killed account, * you might need to prepare the account by removing any reference counters, storage * deposits, etc... * * The dispatch origin of this call must be Signed. * * - `dest`: The recipient of the transfer. * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all * of the funds the account has, causing the sender account to be killed (false), or * transfer everything except at least the existential deposit, which will guarantee to * keep the sender account alive (true). */ transfer_all: TxDescriptor>; /** * Unreserve some balance from a user by force. * * Can only be called by ROOT. */ force_unreserve: TxDescriptor>; /** * Upgrade a specified account. * * - `origin`: Must be `Signed`. * - `who`: The account to be upgraded. * * This will waive the transaction fee if at least all but 10% of the accounts needed to * be upgraded. (We let some not have to be upgraded just in order to allow for the * possibility of churn). */ upgrade_accounts: TxDescriptor>; /** * Set the regular balance of a given account. * * The dispatch origin for this call is `root`. */ force_set_balance: TxDescriptor>; /** * Adjust the total issuance in a saturating way. * * Can only be called by root and always needs a positive `delta`. * * # Example */ force_adjust_total_issuance: TxDescriptor>; /** * Burn the specified liquid free balance from the origin account. * * If the origin's account ends up below the existential deposit as a result * of the burn and `keep_alive` is false, the account will be reaped. * * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible, * this `burn` operation will reduce total issuance by the amount _burned_. */ burn: TxDescriptor>; }; TransactionStorage: { /** * Index and store data off chain. Minimum data size is 1 byte, maximum is * `MaxTransactionSize`. Data will be removed after `RetentionPeriod` blocks, unless * `renew` is called. * * Authorization is required to store data using regular signed/unsigned transactions. * Regular signed transactions require account authorization (see * [`authorize_account`](Self::authorize_account)), regular unsigned transactions require * preimage authorization (see [`authorize_preimage`](Self::authorize_preimage)). * * Emits [`Stored`](Event::Stored) when successful. * * ## Complexity * * O(n*log(n)) of data size, as all data is pushed to an in-memory trie. */ store: TxDescriptor>; /** * Index and store data off chain with an explicit CID configuration. * * Behaves identically to [`store`](Self::store), but the CID configuration * (codec and hashing algorithm) is passed directly as a parameter. * * Emits [`Stored`](Event::Stored) when successful. */ store_with_cid_config: TxDescriptor>; /** * Renew previously stored data. Parameters are the block number that contains previous * `store` or `renew` call and transaction index within that block. Transaction index is * emitted in the `Stored` or `Renewed` event. * * As with [`store`](Self::store), authorization is required to renew data using regular * signed/unsigned transactions. * * Emits [`Renewed`](Event::Renewed) when successful. * * ## Complexity * * O(1). */ renew: TxDescriptor>; /** * Check storage proof for block number `block_number() - RetentionPeriod`. If such a block * does not exist, the proof is expected to be `None`. * * ## Complexity * * Linear w.r.t the number of indexed transactions in the proved block for random probing. * There's a DB read for each transaction. */ check_proof: TxDescriptor>; /** * Authorize an account to store up to a given amount of arbitrary data. The authorization * will expire after a configured number of blocks. * * If the account is already authorized to store data, this will increase the amount of * data the account is authorized to store (and the number of transactions the account may * submit to supply the data), and push back the expiration block. * * Parameters: * * - `who`: The account to be credited with an authorization to store data. * - `transactions`: The number of transactions that `who` may submit to supply that data. * - `bytes`: The number of bytes that `who` may submit. * * The origin for this call must be the pallet's `Authorizer`. Emits * [`AccountAuthorized`](Event::AccountAuthorized) when successful. */ authorize_account: TxDescriptor>; /** * Authorize anyone to store a preimage of the given content hash. The authorization will * expire after a configured number of blocks. * * If authorization already exists for a preimage of the given hash to be stored, the * maximum size of the preimage will be increased to `max_size`, and the expiration block * will be pushed back. * * Parameters: * * - `content_hash`: The hash of the data to be submitted. For [`store`](Self::store) this * is the BLAKE2b-256 hash; for [`store_with_cid_config`](Self::store_with_cid_config) * this is the hash produced by the CID config's hashing algorithm. * - `max_size`: The maximum size, in bytes, of the preimage. * * The origin for this call must be the pallet's `Authorizer`. Emits * [`PreimageAuthorized`](Event::PreimageAuthorized) when successful. */ authorize_preimage: TxDescriptor>; /** * Remove an expired account authorization from storage. Anyone can call this. * * Parameters: * * - `who`: The account with an expired authorization to remove. * * Emits [`ExpiredAccountAuthorizationRemoved`](Event::ExpiredAccountAuthorizationRemoved) * when successful. */ remove_expired_account_authorization: TxDescriptor>; /** * Remove an expired preimage authorization from storage. Anyone can call this. * * Parameters: * * - `content_hash`: The BLAKE2b hash that was authorized. * * Emits * [`ExpiredPreimageAuthorizationRemoved`](Event::ExpiredPreimageAuthorizationRemoved) * when successful. */ remove_expired_preimage_authorization: TxDescriptor>; /** * Refresh the expiration of an existing authorization for an account. * * If the account does not have an authorization, the call will fail. * * Parameters: * * - `who`: The account to be credited with an authorization to store data. * * The origin for this call must be the pallet's `Authorizer`. Emits * [`AccountAuthorizationRefreshed`](Event::AccountAuthorizationRefreshed) when successful. */ refresh_account_authorization: TxDescriptor>; /** * Refresh the expiration of an existing authorization for a preimage of a BLAKE2b hash. * * If the preimage does not have an authorization, the call will fail. * * Parameters: * * - `content_hash`: The BLAKE2b hash of the data to be submitted. * * The origin for this call must be the pallet's `Authorizer`. Emits * [`PreimageAuthorizationRefreshed`](Event::PreimageAuthorizationRefreshed) when * successful. */ refresh_preimage_authorization: TxDescriptor>; }; CollatorSelection: { /** * Set the list of invulnerable (fixed) collators. These collators must do some * preparation, namely to have registered session keys. * * The call will remove any accounts that have not registered keys from the set. That is, * it is non-atomic; the caller accepts all `AccountId`s passed in `new` _individually_ as * acceptable Invulnerables, and is not proposing a _set_ of new Invulnerables. * * This call does not maintain mutual exclusivity of `Invulnerables` and `Candidates`. It * is recommended to use a batch of `add_invulnerable` and `remove_invulnerable` instead. A * `batch_all` can also be used to enforce atomicity. If any candidates are included in * `new`, they should be removed with `remove_invulnerable_candidate` after execution. * * Must be called by the `UpdateOrigin`. */ set_invulnerables: TxDescriptor>; /** * Set the ideal number of non-invulnerable collators. If lowering this number, then the * number of running collators could be higher than this figure. Aside from that edge case, * there should be no other way to have more candidates than the desired number. * * The origin for this call must be the `UpdateOrigin`. */ set_desired_candidates: TxDescriptor>; /** * Set the candidacy bond amount. * * If the candidacy bond is increased by this call, all current candidates which have a * deposit lower than the new bond will be kicked from the list and get their deposits * back. * * The origin for this call must be the `UpdateOrigin`. */ set_candidacy_bond: TxDescriptor>; /** * Register this account as a collator candidate. The account must (a) already have * registered session keys and (b) be able to reserve the `CandidacyBond`. * * This call is not available to `Invulnerable` collators. */ register_as_candidate: TxDescriptor; /** * Deregister `origin` as a collator candidate. Note that the collator can only leave on * session change. The `CandidacyBond` will be unreserved immediately. * * This call will fail if the total number of candidates would drop below * `MinEligibleCollators`. */ leave_intent: TxDescriptor; /** * Add a new account `who` to the list of `Invulnerables` collators. `who` must have * registered session keys. If `who` is a candidate, they will be removed. * * The origin for this call must be the `UpdateOrigin`. */ add_invulnerable: TxDescriptor>; /** * Remove an account `who` from the list of `Invulnerables` collators. `Invulnerables` must * be sorted. * * The origin for this call must be the `UpdateOrigin`. */ remove_invulnerable: TxDescriptor>; /** * Update the candidacy bond of collator candidate `origin` to a new amount `new_deposit`. * * Setting a `new_deposit` that is lower than the current deposit while `origin` is * occupying a top-`DesiredCandidates` slot is not allowed. * * This call will fail if `origin` is not a collator candidate, the updated bond is lower * than the minimum candidacy bond, and/or the amount cannot be reserved. */ update_bond: TxDescriptor>; /** * The caller `origin` replaces a candidate `target` in the collator candidate list by * reserving `deposit`. The amount `deposit` reserved by the caller must be greater than * the existing bond of the target it is trying to replace. * * This call will fail if the caller is already a collator candidate or invulnerable, the * caller does not have registered session keys, the target is not a collator candidate, * and/or the `deposit` amount cannot be reserved. */ take_candidate_slot: TxDescriptor>; }; Session: { /** * Sets the session key(s) of the function caller to `keys`. * * Allows an account to set its session key prior to becoming a validator. * This doesn't take effect until the next session. * * - `origin`: The dispatch origin of this function must be signed. * - `keys`: The new session keys to set. These are the public keys of all sessions keys * setup in the runtime. * - `proof`: The proof that `origin` has access to the private keys of `keys`. See * [`impl_opaque_keys`](sp_runtime::impl_opaque_keys) for more information about the * proof format. */ set_keys: TxDescriptor>; /** * Removes any session key(s) of the function caller. * * This doesn't take effect until the next session. * * The dispatch origin of this function must be Signed and the account must be either be * convertible to a validator ID using the chain's typical addressing system (this usually * means being a controller account) or directly convertible into a validator ID (which * usually means being a stash account). */ purge_keys: TxDescriptor; }; XcmpQueue: { /** * Suspends all XCM executions for the XCMP queue, regardless of the sender's origin. * * - `origin`: Must pass `ControllerOrigin`. */ suspend_xcm_execution: TxDescriptor; /** * Resumes all XCM executions for the XCMP queue. * * Note that this function doesn't change the status of the in/out bound channels. * * - `origin`: Must pass `ControllerOrigin`. */ resume_xcm_execution: TxDescriptor; /** * Overwrites the number of pages which must be in the queue for the other side to be * told to suspend their sending. * * - `origin`: Must pass `Root`. * - `new`: Desired value for `QueueConfigData.suspend_value` */ update_suspend_threshold: TxDescriptor>; /** * Overwrites the number of pages which must be in the queue after which we drop any * further messages from the channel. * * - `origin`: Must pass `Root`. * - `new`: Desired value for `QueueConfigData.drop_threshold` */ update_drop_threshold: TxDescriptor>; /** * Overwrites the number of pages which the queue must be reduced to before it signals * that message sending may recommence after it has been suspended. * * - `origin`: Must pass `Root`. * - `new`: Desired value for `QueueConfigData.resume_threshold` */ update_resume_threshold: TxDescriptor>; }; PolkadotXcm: { /** */ send: TxDescriptor>; /** * Teleport some assets from the local chain to some destination chain. * * **This function is deprecated: Use `limited_teleport_assets` instead.** * * Fee payment on the destination side is made from the asset in the `assets` vector of * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited, * with all fees taken as needed from the asset. * * - `origin`: Must be capable of withdrawing the `assets` and executing XCM. * - `dest`: Destination context for the assets. Will typically be `[Parent, * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from * relay to parachain. * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will * generally be an `AccountId32` value. * - `assets`: The assets to be withdrawn. This should include the assets used to pay the * fee on the `dest` chain. * - `fee_asset_item`: The index into `assets` of the item which should be used to pay * fees. */ teleport_assets: TxDescriptor>; /** * Transfer some assets from the local chain to the destination chain through their local, * destination or remote reserve. * * `assets` must have same reserve location and may not be teleportable to `dest`. * - `assets` have local reserve: transfer assets to sovereign account of destination * chain and forward a notification XCM to `dest` to mint and deposit reserve-based * assets to `beneficiary`. * - `assets` have destination reserve: burn local assets and forward a notification to * `dest` chain to withdraw the reserve assets from this chain's sovereign account and * deposit them to `beneficiary`. * - `assets` have remote reserve: burn local assets, forward XCM to reserve chain to move * reserves from this chain's SA to `dest` chain's SA, and forward another XCM to `dest` * to mint and deposit reserve-based assets to `beneficiary`. * * **This function is deprecated: Use `limited_reserve_transfer_assets` instead.** * * Fee payment on the destination side is made from the asset in the `assets` vector of * index `fee_asset_item`. The weight limit for fees is not provided and thus is unlimited, * with all fees taken as needed from the asset. * * - `origin`: Must be capable of withdrawing the `assets` and executing XCM. * - `dest`: Destination context for the assets. Will typically be `[Parent, * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from * relay to parachain. * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will * generally be an `AccountId32` value. * - `assets`: The assets to be withdrawn. This should include the assets used to pay the * fee on the `dest` (and possibly reserve) chains. * - `fee_asset_item`: The index into `assets` of the item which should be used to pay * fees. */ reserve_transfer_assets: TxDescriptor>; /** * Execute an XCM message from a local, signed, origin. * * An event is deposited indicating whether `msg` could be executed completely or only * partially. * * No more than `max_weight` will be used in its attempted execution. If this is less than * the maximum amount of weight that the message could take to be executed, then no * execution attempt will be made. */ execute: TxDescriptor>; /** * Extoll that a particular destination can be communicated with through a particular * version of XCM. * * - `origin`: Must be an origin specified by AdminOrigin. * - `location`: The destination that is being described. * - `xcm_version`: The latest version of XCM that `location` supports. */ force_xcm_version: TxDescriptor>; /** * Set a safe XCM version (the version that XCM should be encoded with if the most recent * version a destination can accept is unknown). * * - `origin`: Must be an origin specified by AdminOrigin. * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable. */ force_default_xcm_version: TxDescriptor>; /** * Ask a location to notify us regarding their XCM version and any changes to it. * * - `origin`: Must be an origin specified by AdminOrigin. * - `location`: The location to which we should subscribe for XCM version notifications. */ force_subscribe_version_notify: TxDescriptor>; /** * Require that a particular destination should no longer notify us regarding any XCM * version changes. * * - `origin`: Must be an origin specified by AdminOrigin. * - `location`: The location to which we are currently subscribed for XCM version * notifications which we no longer desire. */ force_unsubscribe_version_notify: TxDescriptor>; /** * Transfer some assets from the local chain to the destination chain through their local, * destination or remote reserve. * * `assets` must have same reserve location and may not be teleportable to `dest`. * - `assets` have local reserve: transfer assets to sovereign account of destination * chain and forward a notification XCM to `dest` to mint and deposit reserve-based * assets to `beneficiary`. * - `assets` have destination reserve: burn local assets and forward a notification to * `dest` chain to withdraw the reserve assets from this chain's sovereign account and * deposit them to `beneficiary`. * - `assets` have remote reserve: burn local assets, forward XCM to reserve chain to move * reserves from this chain's SA to `dest` chain's SA, and forward another XCM to `dest` * to mint and deposit reserve-based assets to `beneficiary`. * * Fee payment on the destination side is made from the asset in the `assets` vector of * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight * is needed than `weight_limit`, then the operation will fail and the sent assets may be * at risk. * * - `origin`: Must be capable of withdrawing the `assets` and executing XCM. * - `dest`: Destination context for the assets. Will typically be `[Parent, * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from * relay to parachain. * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will * generally be an `AccountId32` value. * - `assets`: The assets to be withdrawn. This should include the assets used to pay the * fee on the `dest` (and possibly reserve) chains. * - `fee_asset_item`: The index into `assets` of the item which should be used to pay * fees. * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase. */ limited_reserve_transfer_assets: TxDescriptor>; /** * Teleport some assets from the local chain to some destination chain. * * Fee payment on the destination side is made from the asset in the `assets` vector of * index `fee_asset_item`, up to enough to pay for `weight_limit` of weight. If more weight * is needed than `weight_limit`, then the operation will fail and the sent assets may be * at risk. * * - `origin`: Must be capable of withdrawing the `assets` and executing XCM. * - `dest`: Destination context for the assets. Will typically be `[Parent, * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from * relay to parachain. * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will * generally be an `AccountId32` value. * - `assets`: The assets to be withdrawn. This should include the assets used to pay the * fee on the `dest` chain. * - `fee_asset_item`: The index into `assets` of the item which should be used to pay * fees. * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase. */ limited_teleport_assets: TxDescriptor>; /** * Set or unset the global suspension state of the XCM executor. * * - `origin`: Must be an origin specified by AdminOrigin. * - `suspended`: `true` to suspend, `false` to resume. */ force_suspension: TxDescriptor>; /** * Transfer some assets from the local chain to the destination chain through their local, * destination or remote reserve, or through teleports. * * Fee payment on the destination side is made from the asset in the `assets` vector of * index `fee_asset_item` (hence referred to as `fees`), up to enough to pay for * `weight_limit` of weight. If more weight is needed than `weight_limit`, then the * operation will fail and the sent assets may be at risk. * * `assets` (excluding `fees`) must have same reserve location or otherwise be teleportable * to `dest`, no limitations imposed on `fees`. * - for local reserve: transfer assets to sovereign account of destination chain and * forward a notification XCM to `dest` to mint and deposit reserve-based assets to * `beneficiary`. * - for destination reserve: burn local assets and forward a notification to `dest` chain * to withdraw the reserve assets from this chain's sovereign account and deposit them * to `beneficiary`. * - for remote reserve: burn local assets, forward XCM to reserve chain to move reserves * from this chain's SA to `dest` chain's SA, and forward another XCM to `dest` to mint * and deposit reserve-based assets to `beneficiary`. * - for teleports: burn local assets and forward XCM to `dest` chain to mint/teleport * assets and deposit them to `beneficiary`. * * - `origin`: Must be capable of withdrawing the `assets` and executing XCM. * - `dest`: Destination context for the assets. Will typically be `X2(Parent, * Parachain(..))` to send from parachain to parachain, or `X1(Parachain(..))` to send * from relay to parachain. * - `beneficiary`: A beneficiary location for the assets in the context of `dest`. Will * generally be an `AccountId32` value. * - `assets`: The assets to be withdrawn. This should include the assets used to pay the * fee on the `dest` (and possibly reserve) chains. * - `fee_asset_item`: The index into `assets` of the item which should be used to pay * fees. * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase. */ transfer_assets: TxDescriptor>; /** * Claims assets trapped on this pallet because of leftover assets during XCM execution. * * - `origin`: Anyone can call this extrinsic. * - `assets`: The exact assets that were trapped. Use the version to specify what version * was the latest when they were trapped. * - `beneficiary`: The location/account where the claimed assets will be deposited. */ claim_assets: TxDescriptor>; /** * Transfer assets from the local chain to the destination chain using explicit transfer * types for assets and fees. * * `assets` must have same reserve location or may be teleportable to `dest`. Caller must * provide the `assets_transfer_type` to be used for `assets`: * - `TransferType::LocalReserve`: transfer assets to sovereign account of destination * chain and forward a notification XCM to `dest` to mint and deposit reserve-based * assets to `beneficiary`. * - `TransferType::DestinationReserve`: burn local assets and forward a notification to * `dest` chain to withdraw the reserve assets from this chain's sovereign account and * deposit them to `beneficiary`. * - `TransferType::RemoteReserve(reserve)`: burn local assets, forward XCM to `reserve` * chain to move reserves from this chain's SA to `dest` chain's SA, and forward another * XCM to `dest` to mint and deposit reserve-based assets to `beneficiary`. Typically * the remote `reserve` is Asset Hub. * - `TransferType::Teleport`: burn local assets and forward XCM to `dest` chain to * mint/teleport assets and deposit them to `beneficiary`. * * On the destination chain, as well as any intermediary hops, `BuyExecution` is used to * buy execution using transferred `assets` identified by `remote_fees_id`. * Make sure enough of the specified `remote_fees_id` asset is included in the given list * of `assets`. `remote_fees_id` should be enough to pay for `weight_limit`. If more weight * is needed than `weight_limit`, then the operation will fail and the sent assets may be * at risk. * * `remote_fees_id` may use different transfer type than rest of `assets` and can be * specified through `fees_transfer_type`. * * The caller needs to specify what should happen to the transferred assets once they reach * the `dest` chain. This is done through the `custom_xcm_on_dest` parameter, which * contains the instructions to execute on `dest` as a final step. * This is usually as simple as: * `Xcm(vec![DepositAsset { assets: Wild(AllCounted(assets.len())), beneficiary }])`, * but could be something more exotic like sending the `assets` even further. * * - `origin`: Must be capable of withdrawing the `assets` and executing XCM. * - `dest`: Destination context for the assets. Will typically be `[Parent, * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from * relay to parachain, or `(parents: 2, (GlobalConsensus(..), ..))` to send from * parachain across a bridge to another ecosystem destination. * - `assets`: The assets to be withdrawn. This should include the assets used to pay the * fee on the `dest` (and possibly reserve) chains. * - `assets_transfer_type`: The XCM `TransferType` used to transfer the `assets`. * - `remote_fees_id`: One of the included `assets` to be used to pay fees. * - `fees_transfer_type`: The XCM `TransferType` used to transfer the `fees` assets. * - `custom_xcm_on_dest`: The XCM to be executed on `dest` chain as the last step of the * transfer, which also determines what happens to the assets on the destination chain. * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase. */ transfer_assets_using_type_and_then: TxDescriptor>; /** * Authorize another `aliaser` location to alias into the local `origin` making this call. * The `aliaser` is only authorized until the provided `expiry` block number. * The call can also be used for a previously authorized alias in order to update its * `expiry` block number. * * Usually useful to allow your local account to be aliased into from a remote location * also under your control (like your account on another chain). * * WARNING: make sure the caller `origin` (you) trusts the `aliaser` location to act in * their/your name. Once authorized using this call, the `aliaser` can freely impersonate * `origin` in XCM programs executed on the local chain. */ add_authorized_alias: TxDescriptor>; /** * Remove a previously authorized `aliaser` from the list of locations that can alias into * the local `origin` making this call. */ remove_authorized_alias: TxDescriptor>; /** * Remove all previously authorized `aliaser`s that can alias into the local `origin` * making this call. */ remove_all_authorized_aliases: TxDescriptor; }; MessageQueue: { /** * Remove a page which has no more messages remaining to be processed or is stale. */ reap_page: TxDescriptor>; /** * Execute an overweight message. * * Temporary processing errors will be propagated whereas permanent errors are treated * as success condition. * * - `origin`: Must be `Signed`. * - `message_origin`: The origin from which the message to be executed arrived. * - `page`: The page in the queue in which the message to be executed is sitting. * - `index`: The index into the queue of the message to be executed. * - `weight_limit`: The maximum amount of weight allowed to be consumed in the execution * of the message. * * Benchmark complexity considerations: O(index + weight_limit). */ execute_overweight: TxDescriptor>; }; Sudo: { /** * Authenticates the sudo key and dispatches a function call with `Root` origin. */ sudo: TxDescriptor>; /** * Authenticates the sudo key and dispatches a function call with `Root` origin. * This function does not check the weight of the call, and instead allows the * Sudo user to specify the weight of the call. * * The dispatch origin for this call must be _Signed_. */ sudo_unchecked_weight: TxDescriptor>; /** * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo * key. */ set_key: TxDescriptor>; /** * Authenticates the sudo key and dispatches a function call with `Signed` origin from * a given account. * * The dispatch origin for this call must be _Signed_. */ sudo_as: TxDescriptor>; /** * Permanently removes the sudo key. * * **This cannot be un-done.** */ remove_key: TxDescriptor; }; }; type IEvent = { System: { /** * An extrinsic completed successfully. */ ExtrinsicSuccess: PlainDescriptor>; /** * An extrinsic failed. */ ExtrinsicFailed: PlainDescriptor>; /** * `:code` was updated. */ CodeUpdated: PlainDescriptor; /** * A new account was created. */ NewAccount: PlainDescriptor>; /** * An account was reaped. */ KilledAccount: PlainDescriptor>; /** * On on-chain remark happened. */ Remarked: PlainDescriptor>; /** * An upgrade was authorized. */ UpgradeAuthorized: PlainDescriptor>; /** * An invalid authorized upgrade was rejected while trying to apply it. */ RejectedInvalidAuthorizedUpgrade: PlainDescriptor>; }; ParachainSystem: { /** * The validation function has been scheduled to apply. */ ValidationFunctionStored: PlainDescriptor; /** * The validation function was applied as of the contained relay chain block number. */ ValidationFunctionApplied: PlainDescriptor>; /** * The relay-chain aborted the upgrade process. */ ValidationFunctionDiscarded: PlainDescriptor; /** * Some downward messages have been received and will be processed. */ DownwardMessagesReceived: PlainDescriptor>; /** * Downward messages were processed using the given weight. */ DownwardMessagesProcessed: PlainDescriptor>; /** * An upward message was sent to the relay chain. */ UpwardMessageSent: PlainDescriptor>; }; Utility: { /** * Batch of dispatches did not complete fully. Index of first failing dispatch given, as * well as the error. */ BatchInterrupted: PlainDescriptor>; /** * Batch of dispatches completed fully with no error. */ BatchCompleted: PlainDescriptor; /** * Batch of dispatches completed but has errors. */ BatchCompletedWithErrors: PlainDescriptor; /** * A single item within a Batch of dispatches has completed with no error. */ ItemCompleted: PlainDescriptor; /** * A single item within a Batch of dispatches has completed with error. */ ItemFailed: PlainDescriptor>; /** * A call was dispatched. */ DispatchedAs: PlainDescriptor>; /** * Main call was dispatched. */ IfElseMainSuccess: PlainDescriptor; /** * The fallback call was dispatched. */ IfElseFallbackCalled: PlainDescriptor>; }; Balances: { /** * An account was created with some free balance. */ Endowed: PlainDescriptor>; /** * An account was removed whose balance was non-zero but below ExistentialDeposit, * resulting in an outright loss. */ DustLost: PlainDescriptor>; /** * Transfer succeeded. */ Transfer: PlainDescriptor>; /** * A balance was set by root. */ BalanceSet: PlainDescriptor>; /** * Some balance was reserved (moved from free to reserved). */ Reserved: PlainDescriptor>; /** * Some balance was unreserved (moved from reserved to free). */ Unreserved: PlainDescriptor>; /** * Some balance was moved from the reserve of the first account to the second account. * Final argument indicates the destination balance type. */ ReserveRepatriated: PlainDescriptor>; /** * Some amount was deposited (e.g. for transaction fees). */ Deposit: PlainDescriptor>; /** * Some amount was withdrawn from the account (e.g. for transaction fees). */ Withdraw: PlainDescriptor>; /** * Some amount was removed from the account (e.g. for misbehavior). */ Slashed: PlainDescriptor>; /** * Some amount was minted into an account. */ Minted: PlainDescriptor>; /** * Some credit was balanced and added to the TotalIssuance. */ MintedCredit: PlainDescriptor>; /** * Some amount was burned from an account. */ Burned: PlainDescriptor>; /** * Some debt has been dropped from the Total Issuance. */ BurnedDebt: PlainDescriptor>; /** * Some amount was suspended from an account (it can be restored later). */ Suspended: PlainDescriptor>; /** * Some amount was restored into an account. */ Restored: PlainDescriptor>; /** * An account was upgraded. */ Upgraded: PlainDescriptor>; /** * Total issuance was increased by `amount`, creating a credit to be balanced. */ Issued: PlainDescriptor>; /** * Total issuance was decreased by `amount`, creating a debt to be balanced. */ Rescinded: PlainDescriptor>; /** * Some balance was locked. */ Locked: PlainDescriptor>; /** * Some balance was unlocked. */ Unlocked: PlainDescriptor>; /** * Some balance was frozen. */ Frozen: PlainDescriptor>; /** * Some balance was thawed. */ Thawed: PlainDescriptor>; /** * The `TotalIssuance` was forcefully changed. */ TotalIssuanceForced: PlainDescriptor>; /** * Some balance was placed on hold. */ Held: PlainDescriptor>; /** * Held balance was burned from an account. */ BurnedHeld: PlainDescriptor>; /** * A transfer of `amount` on hold from `source` to `dest` was initiated. */ TransferOnHold: PlainDescriptor>; /** * The `transferred` balance is placed on hold at the `dest` account. */ TransferAndHold: PlainDescriptor>; /** * Some balance was released from hold. */ Released: PlainDescriptor>; /** * An unexpected/defensive event was triggered. */ Unexpected: PlainDescriptor>; }; TransactionPayment: { /** * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee, * has been paid by `who`. */ TransactionFeePaid: PlainDescriptor>; }; SkipFeelessPayment: { /** * A transaction fee was skipped. */ FeeSkipped: PlainDescriptor>; }; TransactionStorage: { /** * Stored data under specified index. */ Stored: PlainDescriptor>; /** * Renewed data under specified index. */ Renewed: PlainDescriptor>; /** * Storage proof was successfully checked. */ ProofChecked: PlainDescriptor; /** * An account `who` was authorized to store `bytes` bytes in `transactions` transactions. */ AccountAuthorized: PlainDescriptor>; /** * An authorization for account `who` was refreshed. */ AccountAuthorizationRefreshed: PlainDescriptor>; /** * Authorization was given for a preimage of `content_hash` (not exceeding `max_size`) to * be stored by anyone. */ PreimageAuthorized: PlainDescriptor>; /** * An authorization for a preimage of `content_hash` was refreshed. */ PreimageAuthorizationRefreshed: PlainDescriptor>; /** * An expired account authorization was removed. */ ExpiredAccountAuthorizationRemoved: PlainDescriptor>; /** * An expired preimage authorization was removed. */ ExpiredPreimageAuthorizationRemoved: PlainDescriptor>; }; CollatorSelection: { /** * New Invulnerables were set. */ NewInvulnerables: PlainDescriptor>; /** * A new Invulnerable was added. */ InvulnerableAdded: PlainDescriptor>; /** * An Invulnerable was removed. */ InvulnerableRemoved: PlainDescriptor>; /** * The number of desired candidates was set. */ NewDesiredCandidates: PlainDescriptor>; /** * The candidacy bond was set. */ NewCandidacyBond: PlainDescriptor>; /** * A new candidate joined. */ CandidateAdded: PlainDescriptor>; /** * Bond of a candidate updated. */ CandidateBondUpdated: PlainDescriptor>; /** * A candidate was removed. */ CandidateRemoved: PlainDescriptor>; /** * An account was replaced in the candidate list by another one. */ CandidateReplaced: PlainDescriptor>; /** * An account was unable to be added to the Invulnerables because they did not have keys * registered. Other Invulnerables may have been set. */ InvalidInvulnerableSkipped: PlainDescriptor>; }; Session: { /** * New session has happened. Note that the argument is the session index, not the * block number as the type might suggest. */ NewSession: PlainDescriptor>; /** * The `NewSession` event in the current block also implies a new validator set to be * queued. */ NewQueued: PlainDescriptor; /** * Validator has been disabled. */ ValidatorDisabled: PlainDescriptor>; /** * Validator has been re-enabled. */ ValidatorReenabled: PlainDescriptor>; }; XcmpQueue: { /** * An HRMP message was sent to a sibling parachain. */ XcmpMessageSent: PlainDescriptor>; }; PolkadotXcm: { /** * Execution of an XCM message was attempted. */ Attempted: PlainDescriptor>; /** * An XCM message was sent. */ Sent: PlainDescriptor>; /** * An XCM message failed to send. */ SendFailed: PlainDescriptor>; /** * An XCM message failed to process. */ ProcessXcmError: PlainDescriptor>; /** * Query response received which does not match a registered query. This may be because a * matching query was never registered, it may be because it is a duplicate response, or * because the query timed out. */ UnexpectedResponse: PlainDescriptor>; /** * Query response has been received and is ready for taking with `take_response`. There is * no registered notification call. */ ResponseReady: PlainDescriptor>; /** * Query response has been received and query is removed. The registered notification has * been dispatched and executed successfully. */ Notified: PlainDescriptor>; /** * Query response has been received and query is removed. The registered notification * could not be dispatched because the dispatch weight is greater than the maximum weight * originally budgeted by this runtime for the query result. */ NotifyOverweight: PlainDescriptor>; /** * Query response has been received and query is removed. There was a general error with * dispatching the notification call. */ NotifyDispatchError: PlainDescriptor>; /** * Query response has been received and query is removed. The dispatch was unable to be * decoded into a `Call`; this might be due to dispatch function having a signature which * is not `(origin, QueryId, Response)`. */ NotifyDecodeFailed: PlainDescriptor>; /** * Expected query response has been received but the origin location of the response does * not match that expected. The query remains registered for a later, valid, response to * be received and acted upon. */ InvalidResponder: PlainDescriptor>; /** * Expected query response has been received but the expected origin location placed in * storage by this runtime previously cannot be decoded. The query remains registered. * * This is unexpected (since a location placed in storage in a previously executing * runtime should be readable prior to query timeout) and dangerous since the possibly * valid response will be dropped. Manual governance intervention is probably going to be * needed. */ InvalidResponderVersion: PlainDescriptor>; /** * Received query response has been read and removed. */ ResponseTaken: PlainDescriptor>; /** * Some assets have been placed in an asset trap. */ AssetsTrapped: PlainDescriptor>; /** * An XCM version change notification message has been attempted to be sent. * * The cost of sending it (borne by the chain) is included. */ VersionChangeNotified: PlainDescriptor>; /** * The supported version of a location has been changed. This might be through an * automatic notification or a manual intervention. */ SupportedVersionChanged: PlainDescriptor>; /** * A given location which had a version change subscription was dropped owing to an error * sending the notification to it. */ NotifyTargetSendFail: PlainDescriptor>; /** * A given location which had a version change subscription was dropped owing to an error * migrating the location to our new XCM format. */ NotifyTargetMigrationFail: PlainDescriptor>; /** * Expected query response has been received but the expected querier location placed in * storage by this runtime previously cannot be decoded. The query remains registered. * * This is unexpected (since a location placed in storage in a previously executing * runtime should be readable prior to query timeout) and dangerous since the possibly * valid response will be dropped. Manual governance intervention is probably going to be * needed. */ InvalidQuerierVersion: PlainDescriptor>; /** * Expected query response has been received but the querier location of the response does * not match the expected. The query remains registered for a later, valid, response to * be received and acted upon. */ InvalidQuerier: PlainDescriptor>; /** * A remote has requested XCM version change notification from us and we have honored it. * A version information message is sent to them and its cost is included. */ VersionNotifyStarted: PlainDescriptor>; /** * We have requested that a remote chain send us XCM version change notifications. */ VersionNotifyRequested: PlainDescriptor>; /** * We have requested that a remote chain stops sending us XCM version change * notifications. */ VersionNotifyUnrequested: PlainDescriptor>; /** * Fees were paid from a location for an operation (often for using `SendXcm`). */ FeesPaid: PlainDescriptor>; /** * Some assets have been claimed from an asset trap */ AssetsClaimed: PlainDescriptor>; /** * A XCM version migration finished. */ VersionMigrationFinished: PlainDescriptor>; /** * An `aliaser` location was authorized by `target` to alias it, authorization valid until * `expiry` block number. */ AliasAuthorized: PlainDescriptor>; /** * `target` removed alias authorization for `aliaser`. */ AliasAuthorizationRemoved: PlainDescriptor>; /** * `target` removed all alias authorizations. */ AliasesAuthorizationsRemoved: PlainDescriptor>; }; CumulusXcm: { /** * Downward message is invalid XCM. * \[ id \] */ InvalidFormat: PlainDescriptor>; /** * Downward message is unsupported version of XCM. * \[ id \] */ UnsupportedVersion: PlainDescriptor>; /** * Downward message executed with the given outcome. * \[ id, outcome \] */ ExecutedDownward: PlainDescriptor>; }; MessageQueue: { /** * Message discarded due to an error in the `MessageProcessor` (usually a format error). */ ProcessingFailed: PlainDescriptor>; /** * Message is processed. */ Processed: PlainDescriptor>; /** * Message placed in overweight queue. */ OverweightEnqueued: PlainDescriptor>; /** * This page was reaped. */ PageReaped: PlainDescriptor>; }; Sudo: { /** * A sudo call just took place. */ Sudid: PlainDescriptor>; /** * The sudo key has been updated. */ KeyChanged: PlainDescriptor>; /** * The key was permanently removed. */ KeyRemoved: PlainDescriptor; /** * A [sudo_as](Pallet::sudo_as) call just took place. */ SudoAsDone: PlainDescriptor>; }; }; type IError = { System: { /** * The name of specification does not match between the current runtime * and the new runtime. */ InvalidSpecName: PlainDescriptor; /** * The specification version is not allowed to decrease between the current runtime * and the new runtime. */ SpecVersionNeedsToIncrease: PlainDescriptor; /** * Failed to extract the runtime version from the new runtime. * * Either calling `Core_version` or decoding `RuntimeVersion` failed. */ FailedToExtractRuntimeVersion: PlainDescriptor; /** * Suicide called when the account has non-default composite data. */ NonDefaultComposite: PlainDescriptor; /** * There is a non-zero reference count preventing the account from being purged. */ NonZeroRefCount: PlainDescriptor; /** * The origin filter prevent the call to be dispatched. */ CallFiltered: PlainDescriptor; /** * A multi-block migration is ongoing and prevents the current code from being replaced. */ MultiBlockMigrationsOngoing: PlainDescriptor; /** * No upgrade authorized. */ NothingAuthorized: PlainDescriptor; /** * The submitted code is not authorized. */ Unauthorized: PlainDescriptor; }; ParachainSystem: { /** * Attempt to upgrade validation function while existing upgrade pending. */ OverlappingUpgrades: PlainDescriptor; /** * Polkadot currently prohibits this parachain from upgrading its validation function. */ ProhibitedByPolkadot: PlainDescriptor; /** * The supplied validation function has compiled into a blob larger than Polkadot is * willing to run. */ TooBig: PlainDescriptor; /** * The inherent which supplies the validation data did not run this block. */ ValidationDataNotAvailable: PlainDescriptor; /** * The inherent which supplies the host configuration did not run this block. */ HostConfigurationNotAvailable: PlainDescriptor; /** * No validation function upgrade is currently scheduled. */ NotScheduled: PlainDescriptor; }; Utility: { /** * Too many calls batched. */ TooManyCalls: PlainDescriptor; }; Balances: { /** * Vesting balance too high to send value. */ VestingBalance: PlainDescriptor; /** * Account liquidity restrictions prevent withdrawal. */ LiquidityRestrictions: PlainDescriptor; /** * Balance too low to send value. */ InsufficientBalance: PlainDescriptor; /** * Value too low to create account due to existential deposit. */ ExistentialDeposit: PlainDescriptor; /** * Transfer/payment would kill account. */ Expendability: PlainDescriptor; /** * A vesting schedule already exists for this account. */ ExistingVestingSchedule: PlainDescriptor; /** * Beneficiary account must pre-exist. */ DeadAccount: PlainDescriptor; /** * Number of named reserves exceed `MaxReserves`. */ TooManyReserves: PlainDescriptor; /** * Number of holds exceed `VariantCountOf`. */ TooManyHolds: PlainDescriptor; /** * Number of freezes exceed `MaxFreezes`. */ TooManyFreezes: PlainDescriptor; /** * The issuance cannot be modified since it is already deactivated. */ IssuanceDeactivated: PlainDescriptor; /** * The delta cannot be zero. */ DeltaZero: PlainDescriptor; }; TransactionStorage: { /** * Attempted to call `store`/`renew` outside of block execution. */ BadContext: PlainDescriptor; /** * Data size is not in the allowed range. */ BadDataSize: PlainDescriptor; /** * Too many transactions in the block. */ TooManyTransactions: PlainDescriptor; /** * Invalid configuration. */ NotConfigured: PlainDescriptor; /** * Renewed extrinsic is not found. */ RenewedNotFound: PlainDescriptor; /** * Proof was not expected in this block. */ UnexpectedProof: PlainDescriptor; /** * Proof failed verification. */ InvalidProof: PlainDescriptor; /** * Missing storage proof. */ MissingProof: PlainDescriptor; /** * Unable to verify proof because state data is missing. */ MissingStateData: PlainDescriptor; /** * Double proof check in the block. */ DoubleCheck: PlainDescriptor; /** * Storage proof was not checked in the block. */ ProofNotChecked: PlainDescriptor; /** * Authorization was not found. */ AuthorizationNotFound: PlainDescriptor; /** * Authorization has not expired. */ AuthorizationNotExpired: PlainDescriptor; /** * Content hash was not calculated. */ InvalidContentHash: PlainDescriptor; }; CollatorSelection: { /** * The pallet has too many candidates. */ TooManyCandidates: PlainDescriptor; /** * Leaving would result in too few candidates. */ TooFewEligibleCollators: PlainDescriptor; /** * Account is already a candidate. */ AlreadyCandidate: PlainDescriptor; /** * Account is not a candidate. */ NotCandidate: PlainDescriptor; /** * There are too many Invulnerables. */ TooManyInvulnerables: PlainDescriptor; /** * Account is already an Invulnerable. */ AlreadyInvulnerable: PlainDescriptor; /** * Account is not an Invulnerable. */ NotInvulnerable: PlainDescriptor; /** * Account has no associated validator ID. */ NoAssociatedValidatorId: PlainDescriptor; /** * Validator ID is not yet registered. */ ValidatorNotRegistered: PlainDescriptor; /** * Could not insert in the candidate list. */ InsertToCandidateListFailed: PlainDescriptor; /** * Could not remove from the candidate list. */ RemoveFromCandidateListFailed: PlainDescriptor; /** * New deposit amount would be below the minimum candidacy bond. */ DepositTooLow: PlainDescriptor; /** * Could not update the candidate list. */ UpdateCandidateListFailed: PlainDescriptor; /** * Deposit amount is too low to take the target's slot in the candidate list. */ InsufficientBond: PlainDescriptor; /** * The target account to be replaced in the candidate list is not a candidate. */ TargetIsNotCandidate: PlainDescriptor; /** * The updated deposit amount is equal to the amount already reserved. */ IdenticalDeposit: PlainDescriptor; /** * Cannot lower candidacy bond while occupying a future collator slot in the list. */ InvalidUnreserve: PlainDescriptor; }; Session: { /** * Invalid ownership proof. */ InvalidProof: PlainDescriptor; /** * No associated validator ID for account. */ NoAssociatedValidatorId: PlainDescriptor; /** * Registered duplicate key. */ DuplicatedKey: PlainDescriptor; /** * No keys are associated with this account. */ NoKeys: PlainDescriptor; /** * Key setting account is not live, so it's impossible to associate keys. */ NoAccount: PlainDescriptor; }; XcmpQueue: { /** * Setting the queue config failed since one of its values was invalid. */ BadQueueConfig: PlainDescriptor; /** * The execution is already suspended. */ AlreadySuspended: PlainDescriptor; /** * The execution is already resumed. */ AlreadyResumed: PlainDescriptor; /** * There are too many active outbound channels. */ TooManyActiveOutboundChannels: PlainDescriptor; /** * The message is too big. */ TooBig: PlainDescriptor; }; PolkadotXcm: { /** * The desired destination was unreachable, generally because there is a no way of routing * to it. */ Unreachable: PlainDescriptor; /** * There was some other issue (i.e. not to do with routing) in sending the message. * Perhaps a lack of space for buffering the message. */ SendFailure: PlainDescriptor; /** * The message execution fails the filter. */ Filtered: PlainDescriptor; /** * The message's weight could not be determined. */ UnweighableMessage: PlainDescriptor; /** * The destination `Location` provided cannot be inverted. */ DestinationNotInvertible: PlainDescriptor; /** * The assets to be sent are empty. */ Empty: PlainDescriptor; /** * Could not re-anchor the assets to declare the fees for the destination chain. */ CannotReanchor: PlainDescriptor; /** * Too many assets have been attempted for transfer. */ TooManyAssets: PlainDescriptor; /** * Origin is invalid for sending. */ InvalidOrigin: PlainDescriptor; /** * The version of the `Versioned` value used is not able to be interpreted. */ BadVersion: PlainDescriptor; /** * The given location could not be used (e.g. because it cannot be expressed in the * desired version of XCM). */ BadLocation: PlainDescriptor; /** * The referenced subscription could not be found. */ NoSubscription: PlainDescriptor; /** * The location is invalid since it already has a subscription from us. */ AlreadySubscribed: PlainDescriptor; /** * Could not check-out the assets for teleportation to the destination chain. */ CannotCheckOutTeleport: PlainDescriptor; /** * The owner does not own (all) of the asset that they wish to do the operation on. */ LowBalance: PlainDescriptor; /** * The asset owner has too many locks on the asset. */ TooManyLocks: PlainDescriptor; /** * The given account is not an identifiable sovereign account for any location. */ AccountNotSovereign: PlainDescriptor; /** * The operation required fees to be paid which the initiator could not meet. */ FeesNotMet: PlainDescriptor; /** * A remote lock with the corresponding data could not be found. */ LockNotFound: PlainDescriptor; /** * The unlock operation cannot succeed because there are still consumers of the lock. */ InUse: PlainDescriptor; /** * Invalid asset, reserve chain could not be determined for it. */ InvalidAssetUnknownReserve: PlainDescriptor; /** * Invalid asset, do not support remote asset reserves with different fees reserves. */ InvalidAssetUnsupportedReserve: PlainDescriptor; /** * Too many assets with different reserve locations have been attempted for transfer. */ TooManyReserves: PlainDescriptor; /** * Local XCM execution incomplete. */ LocalExecutionIncomplete: PlainDescriptor; /** * Too many locations authorized to alias origin. */ TooManyAuthorizedAliases: PlainDescriptor; /** * Expiry block number is in the past. */ ExpiresInPast: PlainDescriptor; /** * The alias to remove authorization for was not found. */ AliasNotFound: PlainDescriptor; /** * Local XCM execution incomplete with the actual XCM error and the index of the * instruction that caused the error. */ LocalExecutionIncompleteWithError: PlainDescriptor>; }; MessageQueue: { /** * Page is not reapable because it has items remaining to be processed and is not old * enough. */ NotReapable: PlainDescriptor; /** * Page to be reaped does not exist. */ NoPage: PlainDescriptor; /** * The referenced message could not be found. */ NoMessage: PlainDescriptor; /** * The message was already processed and cannot be processed again. */ AlreadyProcessed: PlainDescriptor; /** * The message is queued for future execution. */ Queued: PlainDescriptor; /** * There is temporarily not enough weight to continue servicing messages. */ InsufficientWeight: PlainDescriptor; /** * This message is temporarily unprocessable. * * Such errors are expected, but not guaranteed, to resolve themselves eventually through * retrying. */ TemporarilyUnprocessable: PlainDescriptor; /** * The queue is paused and no message can be executed from it. * * This can change at any time and may resolve in the future by re-trying. */ QueuePaused: PlainDescriptor; /** * Another call is in progress and needs to finish before this call can happen. */ RecursiveDisallowed: PlainDescriptor; }; Sudo: { /** * Sender must be the Sudo account. */ RequireSudo: PlainDescriptor; }; }; type IConstants = { System: { /** * Block & extrinsics weights: base values and limits. */ BlockWeights: PlainDescriptor>; /** * The maximum length of a block (in bytes). */ BlockLength: PlainDescriptor>; /** * Maximum number of block number to block hash mappings to keep (oldest pruned first). */ BlockHashCount: PlainDescriptor; /** * The weight of runtime database operations the runtime can invoke. */ DbWeight: PlainDescriptor>; /** * Get the chain's in-code version. */ Version: PlainDescriptor>; /** * The designated SS58 prefix of this chain. * * This replaces the "ss58Format" property declared in the chain spec. Reason is * that the runtime should know about the prefix in order to make use of it as * an identifier of the chain. */ SS58Prefix: PlainDescriptor; }; ParachainSystem: { /** * Returns the parachain ID we are running with. */ SelfParaId: PlainDescriptor; }; Timestamp: { /** * The minimum period between blocks. * * Be aware that this is different to the *expected* period that the block production * apparatus provides. Your chosen consensus system will generally work with this to * determine a sensible block time. For example, in the Aura pallet it will be double this * period on default settings. */ MinimumPeriod: PlainDescriptor; }; Utility: { /** * The limit on the number of batched calls. */ batched_calls_limit: PlainDescriptor; }; Balances: { /** * The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO! * * If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for * this pallet. However, you do so at your own risk: this will open up a major DoS vector. * In case you have multiple sources of provider references, you may also get unexpected * behaviour if you set this to zero. * * Bottom line: Do yourself a favour and make it at least one! */ ExistentialDeposit: PlainDescriptor; /** * The maximum number of locks that should exist on an account. * Not strictly enforced, but used for weight estimation. * * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/` */ MaxLocks: PlainDescriptor; /** * The maximum number of named reserves that can exist on an account. * * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/` */ MaxReserves: PlainDescriptor; /** * The maximum number of individual freeze locks that can exist on an account at any time. */ MaxFreezes: PlainDescriptor; }; TransactionPayment: { /** * A fee multiplier for `Operational` extrinsics to compute "virtual tip" to boost their * `priority` * * This value is multiplied by the `final_fee` to obtain a "virtual tip" that is later * added to a tip component in regular `priority` calculations. * It means that a `Normal` transaction can front-run a similarly-sized `Operational` * extrinsic (with no tip), by including a tip value greater than the virtual tip. * * ```rust,ignore * // For `Normal` * let priority = priority_calc(tip); * * // For `Operational` * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier; * let priority = priority_calc(tip + virtual_tip); * ``` * * Note that since we use `final_fee` the multiplier applies also to the regular `tip` * sent with the transaction. So, not only does the transaction get a priority bump based * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational` * transactions. */ OperationalFeeMultiplier: PlainDescriptor; }; TransactionStorage: { /** * Maximum number of indexed transactions in the block. */ MaxBlockTransactions: PlainDescriptor; /** * Maximum data set in a single transaction in bytes. */ MaxTransactionSize: PlainDescriptor; /** * Authorizations expire after this many blocks. */ AuthorizationPeriod: PlainDescriptor; /** * Priority of store/renew transactions. */ StoreRenewPriority: PlainDescriptor; /** * Longevity of store/renew transactions. */ StoreRenewLongevity: PlainDescriptor; /** * Priority of unsigned transactions to remove expired authorizations. */ RemoveExpiredAuthorizationPriority: PlainDescriptor; /** * Longevity of unsigned transactions to remove expired authorizations. */ RemoveExpiredAuthorizationLongevity: PlainDescriptor; }; CollatorSelection: { /** * Account Identifier from which the internal Pot is generated. */ PotId: PlainDescriptor>; /** * Maximum number of candidates that we should have. * * This does not take into account the invulnerables. */ MaxCandidates: PlainDescriptor; /** * Minimum number eligible collators. Should always be greater than zero. This includes * Invulnerable collators. This ensures that there will always be one collator who can * produce a block. */ MinEligibleCollators: PlainDescriptor; /** * Maximum number of invulnerables. */ MaxInvulnerables: PlainDescriptor; /** */ KickThreshold: PlainDescriptor; /** * Gets this pallet's derived pot account. */ pot_account: PlainDescriptor; }; Session: { /** * The amount to be held when setting keys. */ KeyDeposit: PlainDescriptor; }; Aura: { /** * The slot duration Aura should run with, expressed in milliseconds. * * The effective value of this type can be changed with a runtime upgrade. * * For backwards compatibility either use [`MinimumPeriodTimesTwo`] or a const. */ SlotDuration: PlainDescriptor; }; XcmpQueue: { /** * The maximum number of inbound XCMP channels that can be suspended simultaneously. * * Any further channel suspensions will fail and messages may get dropped without further * notice. Choosing a high value (1000) is okay; the trade-off that is described in * [`InboundXcmpSuspended`] still applies at that scale. */ MaxInboundSuspended: PlainDescriptor; /** * Maximal number of outbound XCMP channels that can have messages queued at the same time. * * If this is reached, then no further messages can be sent to channels that do not yet * have a message queued. This should be set to the expected maximum of outbound channels * which is determined by [`Self::ChannelInfo`]. It is important to set this large enough, * since otherwise the congestion control protocol will not work as intended and messages * may be dropped. This value increases the PoV and should therefore not be picked too * high. Governance needs to pay attention to not open more channels than this value. */ MaxActiveOutboundChannels: PlainDescriptor; /** * The maximal page size for HRMP message pages. * * A lower limit can be set dynamically, but this is the hard-limit for the PoV worst case * benchmarking. The limit for the size of a message is slightly below this, since some * overhead is incurred for encoding the format. */ MaxPageSize: PlainDescriptor; }; PolkadotXcm: { /** * This chain's Universal Location. */ UniversalLocation: PlainDescriptor; /** * The latest supported version that we advertise. Generally just set it to * `pallet_xcm::CurrentXcmVersion`. */ AdvertisedXcmVersion: PlainDescriptor; /** * The maximum number of local XCM locks that a single account may have. */ MaxLockers: PlainDescriptor; /** * The maximum number of consumers a single remote lock may have. */ MaxRemoteLockConsumers: PlainDescriptor; }; MessageQueue: { /** * The size of the page; this implies the maximum message size which can be sent. * * A good value depends on the expected message sizes, their weights, the weight that is * available for processing them and the maximal needed message size. The maximal message * size is slightly lower than this as defined by [`MaxMessageLenOf`]. */ HeapSize: PlainDescriptor; /** * The maximum number of stale pages (i.e. of overweight messages) allowed before culling * can happen. Once there are more stale pages than this, then historical pages may be * dropped, even if they contain unprocessed overweight messages. */ MaxStale: PlainDescriptor; /** * The amount of weight (if any) which should be provided to the message queue for * servicing enqueued items `on_initialize`. * * This may be legitimately `None` in the case that you will call * `ServiceQueues::service_queues` manually or set [`Self::IdleMaxServiceWeight`] to have * it run in `on_idle`. */ ServiceWeight: PlainDescriptor>; /** * The maximum amount of weight (if any) to be used from remaining weight `on_idle` which * should be provided to the message queue for servicing enqueued items `on_idle`. * Useful for parachains to process messages at the same block they are received. * * If `None`, it will not call `ServiceQueues::service_queues` in `on_idle`. */ IdleMaxServiceWeight: PlainDescriptor>; }; }; type IViewFns = {}; type IRuntimeCalls = { /** * API necessary for block authorship with aura. */ AuraApi: { /** * Returns the slot duration for Aura. * * Currently, only the value provided by this type at genesis will be used. */ slot_duration: RuntimeDescriptor<[], bigint>; /** * Return the current set of authorities. */ authorities: RuntimeDescriptor<[], Anonymize>; }; /** * API to tell the node side how the relay parent should be chosen. * * A larger offset indicates that the relay parent should not be the tip of the relay chain, * but `N` blocks behind the tip. This offset is then enforced by the runtime. */ RelayParentOffsetApi: { /** * Fetch the slot offset that is expected from the relay chain. */ relay_parent_offset: RuntimeDescriptor<[], number>; }; /** * This runtime API is used to inform potential block authors whether they will * have the right to author at a slot, assuming they have claimed the slot. * * In particular, this API allows Aura-based parachains to regulate their "unincluded segment", * which is the section of the head of the chain which has not yet been made available in the * relay chain. * * When the unincluded segment is short, Aura chains will allow authors to create multiple * blocks per slot in order to build a backlog. When it is saturated, this API will limit * the amount of blocks that can be created. * * Changes: * - Version 2: Update to `can_build_upon` to take a relay chain `Slot` instead of a parachain `Slot`. */ AuraUnincludedSegmentApi: { /** * Whether it is legal to extend the chain, assuming the given block is the most * recently included one as-of the relay parent that will be built against, and * the given relay chain slot. * * This should be consistent with the logic the runtime uses when validating blocks to * avoid issues. * * When the unincluded segment is empty, i.e. `included_hash == at`, where at is the block * whose state we are querying against, this must always return `true` as long as the slot * is more recent than the included block itself. */ can_build_upon: RuntimeDescriptor<[included_hash: FixedSizeBinary<32>, slot: bigint], boolean>; }; /** * The `Core` runtime api that every Substrate runtime needs to implement. */ Core: { /** * Returns the version of the runtime. */ version: RuntimeDescriptor<[], Anonymize>; /** * Execute the given block. */ execute_block: RuntimeDescriptor<[block: Anonymize], undefined>; /** * Initialize a block with the given header and return the runtime executive mode. */ initialize_block: RuntimeDescriptor<[header: Anonymize], Anonymize>; }; /** * The `Metadata` api trait that returns metadata for the runtime. */ Metadata: { /** * Returns the metadata of a runtime. */ metadata: RuntimeDescriptor<[], Binary>; /** * Returns the metadata at a given version. * * If the given `version` isn't supported, this will return `None`. * Use [`Self::metadata_versions`] to find out about supported metadata version of the runtime. */ metadata_at_version: RuntimeDescriptor<[version: number], Anonymize>; /** * Returns the supported metadata versions. * * This can be used to call `metadata_at_version`. */ metadata_versions: RuntimeDescriptor<[], Anonymize>; }; /** * The `BlockBuilder` api trait that provides the required functionality for building a block. */ BlockBuilder: { /** * Apply the given extrinsic. * * Returns an inclusion outcome which specifies if this extrinsic is included in * this block or not. */ apply_extrinsic: RuntimeDescriptor<[extrinsic: Binary], Anonymize>; /** * Finish the current block. */ finalize_block: RuntimeDescriptor<[], Anonymize>; /** * Generate inherent extrinsics. The inherent data will vary from chain to chain. */ inherent_extrinsics: RuntimeDescriptor<[inherent: Anonymize], Anonymize>; /** * Check that the inherents are valid. The inherent data will vary from chain to chain. */ check_inherents: RuntimeDescriptor<[block: Anonymize, data: Anonymize], Anonymize>; }; /** * The `TaggedTransactionQueue` api trait for interfering with the transaction queue. */ TaggedTransactionQueue: { /** * Validate the transaction. * * This method is invoked by the transaction pool to learn details about given transaction. * The implementation should make sure to verify the correctness of the transaction * against current state. The given `block_hash` corresponds to the hash of the block * that is used as current state. * * Note that this call may be performed by the pool multiple times and transactions * might be verified in any possible order. */ validate_transaction: RuntimeDescriptor<[source: TransactionValidityTransactionSource, tx: Binary, block_hash: FixedSizeBinary<32>], Anonymize>; }; /** * The offchain worker api. */ OffchainWorkerApi: { /** * Starts the off-chain task for given block header. */ offchain_worker: RuntimeDescriptor<[header: Anonymize], undefined>; }; /** * Session keys runtime api. */ SessionKeys: { /** * Generate a set of session keys with optionally using the given seed. * The keys should be stored within the keystore exposed via runtime * externalities. * * The seed needs to be a valid `utf8` string. * * Returns the concatenated SCALE encoded public keys. */ generate_session_keys: RuntimeDescriptor<[owner: Binary, seed: Anonymize], Anonymize>; /** * Decode the given public session keys. * * Returns the list of public raw public keys + key type. */ decode_session_keys: RuntimeDescriptor<[encoded: Binary], Anonymize>; }; /** * The API to query account nonce. */ AccountNonceApi: { /** * Get current account nonce of given `AccountId`. */ account_nonce: RuntimeDescriptor<[account: SS58String], number>; }; /** */ TransactionPaymentApi: { /** */ query_info: RuntimeDescriptor<[uxt: Binary, len: number], Anonymize>; /** */ query_fee_details: RuntimeDescriptor<[uxt: Binary, len: number], Anonymize>; /** */ query_weight_to_fee: RuntimeDescriptor<[weight: Anonymize], bigint>; /** */ query_length_to_fee: RuntimeDescriptor<[length: number], bigint>; }; /** */ TransactionPaymentCallApi: { /** * Query information of a dispatch class, weight, and fee of a given encoded `Call`. */ query_call_info: RuntimeDescriptor<[call: Anonymize, len: number], Anonymize>; /** * Query fee details of a given encoded `Call`. */ query_call_fee_details: RuntimeDescriptor<[call: Anonymize, len: number], Anonymize>; /** * Query the output of the current `WeightToFee` given some input. */ query_weight_to_fee: RuntimeDescriptor<[weight: Anonymize], bigint>; /** * Query the output of the current `LengthToFee` given some input. */ query_length_to_fee: RuntimeDescriptor<[length: number], bigint>; }; /** * A trait of XCM payment API. * * API provides functionality for obtaining: * * * the weight required to execute an XCM message, * * a list of acceptable `AssetId`s for message execution payment, * * the cost of the weight in the specified acceptable `AssetId`. * * the fees for an XCM message delivery. * * To determine the execution weight of the calls required for * [`xcm::latest::Instruction::Transact`] instruction, `TransactionPaymentCallApi` can be used. */ XcmPaymentApi: { /** * Returns a list of acceptable payment assets. * * # Arguments * * * `xcm_version`: Version. */ query_acceptable_payment_assets: RuntimeDescriptor<[xcm_version: number], Anonymize>; /** * Returns a weight needed to execute a XCM. * * # Arguments * * * `message`: `VersionedXcm`. */ query_xcm_weight: RuntimeDescriptor<[message: XcmVersionedXcm], Anonymize>; /** * Converts a weight into a fee for the specified `AssetId`. * * # Arguments * * * `weight`: convertible `Weight`. * * `asset`: `VersionedAssetId`. */ query_weight_to_asset_fee: RuntimeDescriptor<[weight: Anonymize, asset: XcmVersionedAssetId], Anonymize>; /** * Query delivery fees V2. * * Get delivery fees for sending a specific `message` to a `destination`. * These always come in a specific asset, defined by the chain. * * # Arguments * * `message`: The message that'll be sent, necessary because most delivery fees are based on the * size of the message. * * `destination`: The destination to send the message to. Different destinations may use * different senders that charge different fees. */ query_delivery_fees: RuntimeDescriptor<[destination: XcmVersionedLocation, message: XcmVersionedXcm, asset_id: XcmVersionedAssetId], Anonymize>; }; /** * API for dry-running extrinsics and XCM programs to get the programs that need to be passed to the fees API. * * All calls return a vector of tuples (location, xcm) where each "xcm" is executed in "location". * If there's local execution, the location will be "Here". * This vector can be used to calculate both execution and delivery fees. * * Calls or XCMs might fail when executed, this doesn't mean the result of these calls will be an `Err`. * In those cases, there might still be a valid result, with the execution error inside it. * The only reasons why these calls might return an error are listed in the [`Error`] enum. */ DryRunApi: { /** * Dry run call V2. */ dry_run_call: RuntimeDescriptor<[origin: Anonymize, call: Anonymize, result_xcms_version: number], Anonymize>; /** * Dry run XCM program */ dry_run_xcm: RuntimeDescriptor<[origin_location: XcmVersionedLocation, xcm: XcmVersionedXcm], Anonymize>; }; /** * API for useful conversions between XCM `Location` and `AccountId`. */ LocationToAccountApi: { /** * Converts `Location` to `AccountId`. */ convert_location: RuntimeDescriptor<[location: XcmVersionedLocation], Anonymize>; }; /** * API for querying trusted reserves and trusted teleporters. */ TrustedQueryApi: { /** * Returns if the location is a trusted reserve for the asset. * * # Arguments * * `asset`: `VersionedAsset`. * * `location`: `VersionedLocation`. */ is_trusted_reserve: RuntimeDescriptor<[asset: XcmVersionedAsset, location: XcmVersionedLocation], Anonymize>; /** * Returns if the asset can be teleported to the location. * * # Arguments * * `asset`: `VersionedAsset`. * * `location`: `VersionedLocation`. */ is_trusted_teleporter: RuntimeDescriptor<[asset: XcmVersionedAsset, location: XcmVersionedLocation], Anonymize>; }; /** * API for querying XCM authorized aliases */ AuthorizedAliasersApi: { /** * Returns locations allowed to alias into and act as `target`. */ authorized_aliasers: RuntimeDescriptor<[target: XcmVersionedLocation], Anonymize>; /** * Returns whether `origin` is allowed to alias into and act as `target`. */ is_authorized_alias: RuntimeDescriptor<[origin: XcmVersionedLocation, target: XcmVersionedLocation], Anonymize>; }; /** * Runtime api to collect information about a collation. * * Version history: * - Version 2: Changed [`Self::collect_collation_info`] signature * - Version 3: Signals to the node to use version 1 of [`ParachainBlockData`]. */ CollectCollationInfo: { /** * Collect information about a collation. * * The given `header` is the header of the built block for that * we are collecting the collation info for. */ collect_collation_info: RuntimeDescriptor<[header: Anonymize], Anonymize>; }; /** * Runtime API trait for transaction storage support. */ TransactionStorageApi: { /** * Get the actual value of a retention period in blocks. */ retention_period: RuntimeDescriptor<[], number>; }; /** * API to interact with `RuntimeGenesisConfig` for the runtime */ GenesisBuilder: { /** * Build `RuntimeGenesisConfig` from a JSON blob not using any defaults and store it in the * storage. * * In the case of a FRAME-based runtime, this function deserializes the full * `RuntimeGenesisConfig` from the given JSON blob and puts it into the storage. If the * provided JSON blob is incorrect or incomplete or the deserialization fails, an error * is returned. * * Please note that provided JSON blob must contain all `RuntimeGenesisConfig` fields, no * defaults will be used. */ build_state: RuntimeDescriptor<[json: Binary], Anonymize>; /** * Returns a JSON blob representation of the built-in `RuntimeGenesisConfig` identified by * `id`. * * If `id` is `None` the function should return JSON blob representation of the default * `RuntimeGenesisConfig` struct of the runtime. Implementation must provide default * `RuntimeGenesisConfig`. * * Otherwise function returns a JSON representation of the built-in, named * `RuntimeGenesisConfig` preset identified by `id`, or `None` if such preset does not * exist. Returned `Vec` contains bytes of JSON blob (patch) which comprises a list of * (potentially nested) key-value pairs that are intended for customizing the default * runtime genesis config. The patch shall be merged (rfc7386) with the JSON representation * of the default `RuntimeGenesisConfig` to create a comprehensive genesis config that can * be used in `build_state` method. */ get_preset: RuntimeDescriptor<[id: Anonymize], Anonymize>; /** * Returns a list of identifiers for available builtin `RuntimeGenesisConfig` presets. * * The presets from the list can be queried with [`GenesisBuilder::get_preset`] method. If * no named presets are provided by the runtime the list is empty. */ preset_names: RuntimeDescriptor<[], Anonymize>; }; /** * Runtime api used to access general info about a parachain runtime. */ GetParachainInfo: { /** * Retrieve the parachain id used for runtime. */ parachain_id: RuntimeDescriptor<[], number>; }; }; export type BulletinDispatchError = Anonymize; type IAsset = PlainDescriptor; export type BulletinExtensions = {}; type PalletsTypedef = { __storage: IStorage; __tx: ICalls; __event: IEvent; __error: IError; __const: IConstants; __view: IViewFns; }; export type Bulletin = { descriptors: { pallets: PalletsTypedef; apis: IRuntimeCalls; } & Promise; metadataTypes: Promise; asset: IAsset; extensions: BulletinExtensions; getMetadata: () => Promise; genesis: string | undefined; }; declare const _allDescriptors: Bulletin; export default _allDescriptors; export type BulletinApis = ApisFromDef; export type BulletinQueries = QueryFromPalletsDef; export type BulletinCalls = TxFromPalletsDef; export type BulletinEvents = EventsFromPalletsDef; export type BulletinErrors = ErrorsFromPalletsDef; export type BulletinConstants = ConstFromPalletsDef; export type BulletinViewFns = ViewFnsFromPalletsDef; export type BulletinCallData = Anonymize & { value: { type: string; }; }; type AllInteractions = { storage: { System: ['Account', 'ExtrinsicCount', 'InherentsApplied', 'BlockWeight', 'BlockSize', 'BlockHash', 'ExtrinsicData', 'Number', 'ParentHash', 'Digest', 'Events', 'EventCount', 'EventTopics', 'LastRuntimeUpgrade', 'UpgradedToU32RefCount', 'UpgradedToTripleRefCount', 'ExecutionPhase', 'AuthorizedUpgrade', 'ExtrinsicWeightReclaimed']; ParachainSystem: ['UnincludedSegment', 'AggregatedUnincludedSegment', 'PendingValidationCode', 'NewValidationCode', 'ValidationData', 'DidSetValidationCode', 'LastRelayChainBlockNumber', 'UpgradeRestrictionSignal', 'UpgradeGoAhead', 'RelayStateProof', 'RelevantMessagingState', 'HostConfiguration', 'LastDmqMqcHead', 'LastHrmpMqcHeads', 'ProcessedDownwardMessages', 'LastProcessedDownwardMessage', 'HrmpWatermark', 'LastProcessedHrmpMessage', 'HrmpOutboundMessages', 'UpwardMessages', 'PendingUpwardMessages', 'PendingUpwardSignals', 'UpwardDeliveryFeeFactor', 'AnnouncedHrmpMessagesPerCandidate', 'ReservedXcmpWeightOverride', 'ReservedDmpWeightOverride', 'CustomValidationHeadData']; Timestamp: ['Now', 'DidUpdate']; ParachainInfo: ['ParachainId']; Balances: ['TotalIssuance', 'InactiveIssuance', 'Account', 'Locks', 'Reserves', 'Holds', 'Freezes']; TransactionPayment: ['NextFeeMultiplier', 'StorageVersion', 'TxPaymentCredit']; TransactionStorage: ['Authorizations', 'Transactions', 'ByteFee', 'EntryFee', 'RetentionPeriod', 'BlockTransactions', 'ProofChecked']; Authorship: ['Author']; CollatorSelection: ['Invulnerables', 'CandidateList', 'LastAuthoredBlock', 'DesiredCandidates', 'CandidacyBond']; Session: ['Validators', 'CurrentIndex', 'QueuedChanged', 'QueuedKeys', 'DisabledValidators', 'NextKeys', 'KeyOwner', 'ExternallySetKeys']; Aura: ['Authorities', 'CurrentSlot']; AuraExt: ['Authorities', 'RelaySlotInfo']; XcmpQueue: ['InboundXcmpSuspended', 'OutboundXcmpStatus', 'OutboundXcmpMessages', 'SignalMessages', 'QueueConfig', 'QueueSuspended', 'DeliveryFeeFactor']; PolkadotXcm: ['QueryCounter', 'Queries', 'AssetTraps', 'SafeXcmVersion', 'SupportedVersion', 'VersionNotifiers', 'VersionNotifyTargets', 'VersionDiscoveryQueue', 'CurrentMigration', 'RemoteLockedFungibles', 'LockedFungibles', 'XcmExecutionSuspended', 'ShouldRecordXcm', 'RecordedXcm', 'AuthorizedAliases']; MessageQueue: ['BookStateFor', 'ServiceHead', 'Pages']; Sudo: ['Key']; }; tx: { System: ['remark', 'set_heap_pages', 'set_code', 'set_code_without_checks', 'set_storage', 'kill_storage', 'kill_prefix', 'remark_with_event', 'authorize_upgrade', 'authorize_upgrade_without_checks', 'apply_authorized_upgrade']; ParachainSystem: ['set_validation_data', 'sudo_send_upward_message']; Timestamp: ['set']; Utility: ['batch', 'as_derivative', 'batch_all', 'dispatch_as', 'force_batch', 'with_weight', 'if_else', 'dispatch_as_fallible']; Balances: ['transfer_allow_death', 'force_transfer', 'transfer_keep_alive', 'transfer_all', 'force_unreserve', 'upgrade_accounts', 'force_set_balance', 'force_adjust_total_issuance', 'burn']; TransactionStorage: ['store', 'store_with_cid_config', 'renew', 'check_proof', 'authorize_account', 'authorize_preimage', 'remove_expired_account_authorization', 'remove_expired_preimage_authorization', 'refresh_account_authorization', 'refresh_preimage_authorization']; CollatorSelection: ['set_invulnerables', 'set_desired_candidates', 'set_candidacy_bond', 'register_as_candidate', 'leave_intent', 'add_invulnerable', 'remove_invulnerable', 'update_bond', 'take_candidate_slot']; Session: ['set_keys', 'purge_keys']; XcmpQueue: ['suspend_xcm_execution', 'resume_xcm_execution', 'update_suspend_threshold', 'update_drop_threshold', 'update_resume_threshold']; PolkadotXcm: ['send', 'teleport_assets', 'reserve_transfer_assets', 'execute', 'force_xcm_version', 'force_default_xcm_version', 'force_subscribe_version_notify', 'force_unsubscribe_version_notify', 'limited_reserve_transfer_assets', 'limited_teleport_assets', 'force_suspension', 'transfer_assets', 'claim_assets', 'transfer_assets_using_type_and_then', 'add_authorized_alias', 'remove_authorized_alias', 'remove_all_authorized_aliases']; MessageQueue: ['reap_page', 'execute_overweight']; Sudo: ['sudo', 'sudo_unchecked_weight', 'set_key', 'sudo_as', 'remove_key']; }; events: { System: ['ExtrinsicSuccess', 'ExtrinsicFailed', 'CodeUpdated', 'NewAccount', 'KilledAccount', 'Remarked', 'UpgradeAuthorized', 'RejectedInvalidAuthorizedUpgrade']; ParachainSystem: ['ValidationFunctionStored', 'ValidationFunctionApplied', 'ValidationFunctionDiscarded', 'DownwardMessagesReceived', 'DownwardMessagesProcessed', 'UpwardMessageSent']; Utility: ['BatchInterrupted', 'BatchCompleted', 'BatchCompletedWithErrors', 'ItemCompleted', 'ItemFailed', 'DispatchedAs', 'IfElseMainSuccess', 'IfElseFallbackCalled']; Balances: ['Endowed', 'DustLost', 'Transfer', 'BalanceSet', 'Reserved', 'Unreserved', 'ReserveRepatriated', 'Deposit', 'Withdraw', 'Slashed', 'Minted', 'MintedCredit', 'Burned', 'BurnedDebt', 'Suspended', 'Restored', 'Upgraded', 'Issued', 'Rescinded', 'Locked', 'Unlocked', 'Frozen', 'Thawed', 'TotalIssuanceForced', 'Held', 'BurnedHeld', 'TransferOnHold', 'TransferAndHold', 'Released', 'Unexpected']; TransactionPayment: ['TransactionFeePaid']; SkipFeelessPayment: ['FeeSkipped']; TransactionStorage: ['Stored', 'Renewed', 'ProofChecked', 'AccountAuthorized', 'AccountAuthorizationRefreshed', 'PreimageAuthorized', 'PreimageAuthorizationRefreshed', 'ExpiredAccountAuthorizationRemoved', 'ExpiredPreimageAuthorizationRemoved']; CollatorSelection: ['NewInvulnerables', 'InvulnerableAdded', 'InvulnerableRemoved', 'NewDesiredCandidates', 'NewCandidacyBond', 'CandidateAdded', 'CandidateBondUpdated', 'CandidateRemoved', 'CandidateReplaced', 'InvalidInvulnerableSkipped']; Session: ['NewSession', 'NewQueued', 'ValidatorDisabled', 'ValidatorReenabled']; XcmpQueue: ['XcmpMessageSent']; PolkadotXcm: ['Attempted', 'Sent', 'SendFailed', 'ProcessXcmError', 'UnexpectedResponse', 'ResponseReady', 'Notified', 'NotifyOverweight', 'NotifyDispatchError', 'NotifyDecodeFailed', 'InvalidResponder', 'InvalidResponderVersion', 'ResponseTaken', 'AssetsTrapped', 'VersionChangeNotified', 'SupportedVersionChanged', 'NotifyTargetSendFail', 'NotifyTargetMigrationFail', 'InvalidQuerierVersion', 'InvalidQuerier', 'VersionNotifyStarted', 'VersionNotifyRequested', 'VersionNotifyUnrequested', 'FeesPaid', 'AssetsClaimed', 'VersionMigrationFinished', 'AliasAuthorized', 'AliasAuthorizationRemoved', 'AliasesAuthorizationsRemoved']; CumulusXcm: ['InvalidFormat', 'UnsupportedVersion', 'ExecutedDownward']; MessageQueue: ['ProcessingFailed', 'Processed', 'OverweightEnqueued', 'PageReaped']; Sudo: ['Sudid', 'KeyChanged', 'KeyRemoved', 'SudoAsDone']; }; errors: { System: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered', 'MultiBlockMigrationsOngoing', 'NothingAuthorized', 'Unauthorized']; ParachainSystem: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled']; Utility: ['TooManyCalls']; Balances: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'Expendability', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves', 'TooManyHolds', 'TooManyFreezes', 'IssuanceDeactivated', 'DeltaZero']; TransactionStorage: ['BadContext', 'BadDataSize', 'TooManyTransactions', 'NotConfigured', 'RenewedNotFound', 'UnexpectedProof', 'InvalidProof', 'MissingProof', 'MissingStateData', 'DoubleCheck', 'ProofNotChecked', 'AuthorizationNotFound', 'AuthorizationNotExpired', 'InvalidContentHash']; CollatorSelection: ['TooManyCandidates', 'TooFewEligibleCollators', 'AlreadyCandidate', 'NotCandidate', 'TooManyInvulnerables', 'AlreadyInvulnerable', 'NotInvulnerable', 'NoAssociatedValidatorId', 'ValidatorNotRegistered', 'InsertToCandidateListFailed', 'RemoveFromCandidateListFailed', 'DepositTooLow', 'UpdateCandidateListFailed', 'InsufficientBond', 'TargetIsNotCandidate', 'IdenticalDeposit', 'InvalidUnreserve']; Session: ['InvalidProof', 'NoAssociatedValidatorId', 'DuplicatedKey', 'NoKeys', 'NoAccount']; XcmpQueue: ['BadQueueConfig', 'AlreadySuspended', 'AlreadyResumed', 'TooManyActiveOutboundChannels', 'TooBig']; PolkadotXcm: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed', 'CannotCheckOutTeleport', 'LowBalance', 'TooManyLocks', 'AccountNotSovereign', 'FeesNotMet', 'LockNotFound', 'InUse', 'InvalidAssetUnknownReserve', 'InvalidAssetUnsupportedReserve', 'TooManyReserves', 'LocalExecutionIncomplete', 'TooManyAuthorizedAliases', 'ExpiresInPast', 'AliasNotFound', 'LocalExecutionIncompleteWithError']; MessageQueue: ['NotReapable', 'NoPage', 'NoMessage', 'AlreadyProcessed', 'Queued', 'InsufficientWeight', 'TemporarilyUnprocessable', 'QueuePaused', 'RecursiveDisallowed']; Sudo: ['RequireSudo']; }; constants: { System: ['BlockWeights', 'BlockLength', 'BlockHashCount', 'DbWeight', 'Version', 'SS58Prefix']; ParachainSystem: ['SelfParaId']; Timestamp: ['MinimumPeriod']; Utility: ['batched_calls_limit']; Balances: ['ExistentialDeposit', 'MaxLocks', 'MaxReserves', 'MaxFreezes']; TransactionPayment: ['OperationalFeeMultiplier']; TransactionStorage: ['MaxBlockTransactions', 'MaxTransactionSize', 'AuthorizationPeriod', 'StoreRenewPriority', 'StoreRenewLongevity', 'RemoveExpiredAuthorizationPriority', 'RemoveExpiredAuthorizationLongevity']; CollatorSelection: ['PotId', 'MaxCandidates', 'MinEligibleCollators', 'MaxInvulnerables', 'KickThreshold', 'pot_account']; Session: ['KeyDeposit']; Aura: ['SlotDuration']; XcmpQueue: ['MaxInboundSuspended', 'MaxActiveOutboundChannels', 'MaxPageSize']; PolkadotXcm: ['UniversalLocation', 'AdvertisedXcmVersion', 'MaxLockers', 'MaxRemoteLockConsumers']; MessageQueue: ['HeapSize', 'MaxStale', 'ServiceWeight', 'IdleMaxServiceWeight']; }; viewFns: {}; apis: { AuraApi: ['slot_duration', 'authorities']; RelayParentOffsetApi: ['relay_parent_offset']; AuraUnincludedSegmentApi: ['can_build_upon']; Core: ['version', 'execute_block', 'initialize_block']; Metadata: ['metadata', 'metadata_at_version', 'metadata_versions']; BlockBuilder: ['apply_extrinsic', 'finalize_block', 'inherent_extrinsics', 'check_inherents']; TaggedTransactionQueue: ['validate_transaction']; OffchainWorkerApi: ['offchain_worker']; SessionKeys: ['generate_session_keys', 'decode_session_keys']; AccountNonceApi: ['account_nonce']; TransactionPaymentApi: ['query_info', 'query_fee_details', 'query_weight_to_fee', 'query_length_to_fee']; TransactionPaymentCallApi: ['query_call_info', 'query_call_fee_details', 'query_weight_to_fee', 'query_length_to_fee']; XcmPaymentApi: ['query_acceptable_payment_assets', 'query_xcm_weight', 'query_weight_to_asset_fee', 'query_delivery_fees']; DryRunApi: ['dry_run_call', 'dry_run_xcm']; LocationToAccountApi: ['convert_location']; TrustedQueryApi: ['is_trusted_reserve', 'is_trusted_teleporter']; AuthorizedAliasersApi: ['authorized_aliasers', 'is_authorized_alias']; CollectCollationInfo: ['collect_collation_info']; TransactionStorageApi: ['retention_period']; GenesisBuilder: ['build_state', 'get_preset', 'preset_names']; GetParachainInfo: ['parachain_id']; }; }; export type BulletinWhitelistEntry = PalletKey | `query.${NestedKey}` | `tx.${NestedKey}` | `event.${NestedKey}` | `error.${NestedKey}` | `const.${NestedKey}` | `view.${NestedKey}` | `api.${NestedKey}`; type PalletKey = `*.${({ [K in keyof AllInteractions]: K extends 'apis' ? never : keyof AllInteractions[K]; })[keyof AllInteractions]}`; type NestedKey> = "*" | { [P in keyof D & string]: `${P}.*` | `${P}.${D[P][number]}`; }[keyof D & string];