@galacticcouncil/descriptors
Version:
Hydration papi (polkadot-api) descriptors
1,036 lines (1,028 loc) • 368 kB
TypeScript
import { StorageDescriptor, PlainDescriptor, TxDescriptor, RuntimeDescriptor, Enum, ApisFromDef, QueryFromPalletsDef, TxFromPalletsDef, EventsFromPalletsDef, ErrorsFromPalletsDef, ConstFromPalletsDef, ViewFnsFromPalletsDef, SS58String, SizedHex, FixedSizeArray } from "polkadot-api";
import type { I5sesotjlssv2d, Iffmde3ekjedi9, I4mddgoa69c0a2, I3gicjuq7v22fo, I95g6i7ilua7lq, Ieniouoqkq4icf, Phase, Ibgl04rn6nbfm6, I4q39t5hn830vp, I1q8tnt1cluu5j, I8ds64oj6581v0, Ia7pdug7cdsg8g, I4sklc1tvo63k3, I9bin2jc70qt6q, I4ftk0glls7946, I910puuahutflf, I4nfjdef0ibh44, I74af64m08r6as, Ic8ann3kre6vdm, I1j72qfgdejqsv, I60biiepd74113, I6mhebgj62g585, I3vhcedhm4hpvm, I526daka7j7b17, Ifanv2kvm586s4, I5rsgtofmn5lli, Idned7t7knml6b, I2itl2k1j2q8nf, Iegjdtqhbb6qh9, I9p9lq3rej5bhc, Iag146hmjgqfgj, I8uo3fpd3bcc6f, Ic3orq32is6lrl, ConvictionVotingVoteVoting, I6ouflveob4eli, If9jidduiuq7vv, I3tt16iedrf9nu, Ifj0li5nn5unet, If9iqq7i64mur8, I8ikpj86u2na1q, Icbsch55a85u5u, Ib9d9r6ft4gk7o, I5ugnv0dol8v8t, I1ksaufim9dq1c, Ielgh4t8o7rcvt, I3rvqhkck00laj, I9jd27rnpm8ttv, I7bcpl5g2rcql5, I4vdvk2616mp4t, Iep7au1720bm0e, I48olja7kd2ijk, I94ue2k0qjjmh, Icmar3g4068bt5, I2j729bmgsdiuo, I5bbnmrss3h025, I200n1ov5tbcvr, Ibn3i0ad6beo5l, I5aq7tv9lofc3v, I10uqvdcdcld3o, I3fgr93o42d9hi, Ihjc2vmjfhsmq, I663kh18bno0fo, I1p5pqg6bllgtl, Ier4eivhqndrf3, I6tni6burv9dng, I4ojmnsk1dchql, Iesq88051ch8ht, I9qpa0evftgoo5, I4qc61lpfqml75, I1stghsu756nk9, Idqn78enhf4jrq, Ic02kut0350gb0, Ic3l568el19b24, Ib0hfhkohlekcj, I32lgu058i52q9, Ie7atdsih6q14b, I4totqt881mlti, Id32h28hjj1tch, I66gvo4ilpv28i, Ifn6q3equiq9qi, I8kbiofpboejrm, I9ae1049tiuvhb, I1os9h4ivict7u, Isa48262v9oqu, In7a38730s6qs, If15el53dd76v9, I9s0ave7t0vnrk, I4fo08joqmcqnm, Ibafpkl9hhno69, I9m0752cdvui5o, Ie5fbn0f5capo3, Ia9ai1mp1viqjd, Ic1e6uvbf8ado3, Ie7oqvfdar8r2, I6v8sm60vvkmk7, I92pum5p0t4pat, Ievdsibhthdgfm, I6uavo5oia2vma, I7cibfirq2tgp9, I3orh1nv01rrjo, I6h476hpq98c65, I1moso5oagpiea, Ibeb4n9vpjefp3, Id7murq9s9fg6h, Ied9mja4bq7va8, I4f7jul8ljs54r, I5agg650597e49, I2ev73t79f46tb, Iab64mce6q91i, I14p0q0qs0fqbj, I666bl2fqjkejo, I7ji3jng252el9, I3v9h9f3mpm1l8, I9mnj4k4u8ls2c, I2kt2u1flctk2q, Iegi6etm6vhoqr, I2e1ekg17a2uj2, I9uff8o8g5b5av, I1acluqiqlacck, Idkqesere66fs7, Ifs54vj2idl9k4, Icc4kdflqd2pde, Ibchucv5dtvt2n, I3e3bva29cv4gl, Ideaemvoneh309, I3d9o9d7epp66v, I6lqh1vgb4mcja, Idnsr2pndm36h0, Itcpv4hqecjfj, I8steo882k7qns, I9qtj66dgng975, I5f178ab6b89t3, Iduerupfbc8ruc, Ia57pohc1kphgk, Icbccs0ug47ilf, I7og87gfic9ddg, Ida2ijjar0n0j3, Ing3etrevsfg0, Ietsl92b11kilg, I7cjmd8tn4p2o2, Icqdi7b9m95ug3, Ieuqv44kptstcs, I2lsmg0nf1stqd, I6vhvcln14dp4d, Ievca65alkkho9, I2qkf9i0e8mf1f, Iefviakco48cs2, Iakb7idgif10m8, Id7aqsj1u6b2r2, Icah19jgge5j3e, I2bi2kbaaunr13, Ib3jvgupt4scl5, I3iojc1k1m6nu7, I9q8qmop6bko5m, Ial2ta95n8ff3b, Iammrvujtc5lnk, I87j02rt3f17j8, Iasmn3c065hq91, Ia5kd7m19ap7ge, Ieq7brqoubndin, Ie8ft8rd6cil27, I2k37dcoppgins, Ia05t9pjenemsb, I4rm8rabbdt645, I9sh4kg79d0vn, I5k5ne4orot4oe, I4v9dok43o95sq, Ib2kqt4hdmd5u5, I8utns9aeu3t6o, I35cf63e7kg5on, Ibq6b0nsk23kj8, Ifc3gfgolmaqf7, I651losl68jmo5, I5dlvf0cogf3c3, Ie6nueo20p04gk, I3qt1hgg4djhgb, I77a9b6eik0rui, Ics8sn0t3vlpat, I6p5nbogrodkcc, Ic11mlh16sngai, I4vbsn8c7ui70f, I60m5cjc6e18ab, Iauknf9up388mv, Ieh252ua9757u1, Iest0fomljvrb6, I2d6orhhgh5et2, I8ij5e2p0aqu6i, Ijqmlm7h71nc1, Ibmmi1tbvqjkf9, I4f24vd3pvt9k, Icjk91npopm3h9, Ie03o0h06lol9p, I1ko6jcqv0sqm4, I6a1eig522s2p0, I7mcjnqos9shs1, I6ap0qjh5n5817, I6pjjpfvhvcfru, Ia5le7udkgbaq9, Ionfhf9va2t31, Ibbvcet1pv1l61, I67bpqa7o2ocua, I2holodggoluon, Ib5umq5uf644jr, I9r83fr4b3rmmj, I24s4g6gkj5oec, Idcabvplu05lea, Id38gdpcotl637, I73q3qf5u7nnqg, Idpm1bc2cr6dgj, Itmchvgqfl28g, I4gpglecit15nf, I10hmgseei3j6r, I8p4numg1r4ojm, Idtucog650c7f8, I4kvfua9fqrpi2, I7t5blhj97u8r7, I21qpgggberqt3, Id7r4m9aulb7sn, Ielqbuofrsq2ri, I3hno1r9147mro, Iaihikf7d0fpt7, Iaehj4ajaudum7, Id83ilm95if0sl, I82r4tvnf2s05i, Icojrb9unj3i10, Ib9aiguc778ujf, If4ebvclj2ugvi, Ia5cotcvi888ln, I21jsa919m88fd, Iegif7m3upfe1k, I9kt8c221c83ln, Ic76kfh5ebqkpl, Icscpmubum33bq, I21d2olof7eb60, Ibgm4rnf22lal1, Ie68np0vpihith, I9bnv6lu0crf1q, Iauhjqifrdklq7, Ie1uso9m8rt5cf, Ic3vmcebni2jj7, If1007933akv96, I1femd1o6lf4os, I88qo502j1hm6r, I44sqbdseede38, I203slt75ll6b5, I9buamva6m987d, I931cottvong90, Ifmc9boeeia623, Ibplkiqg5rvr3e, Icnmrtlo128skq, Icojqvn3afk41n, I5r8t4iaend96p, Iabpgqcjikia83, Icgljjb6j82uhn, I4g15ko4u63fja, If08sfhqn8ujfr, Ic4rgfgksgmm3e, I3dj14b7k3rkm5, Ic5egmm215ml6k, Ifg79652v4hqd3, I34mub5dacthli, I5fvdd841odbi3, I35vouom6s9r2, Ie6kgk6f04rsvk, Ifgqf2rskq94om, Itom7fk49o0c9, Ie30stbbeaul1o, I4arjljr6dpflb, I7aold6s47n103, Ic952bubvq4k7d, Ihfphjolmsqq1, Iftvbctbo05fu4, XcmVersionedXcm, Ic0c3req3mlc1l, XcmVersionedAssetId, I7ocn4njqde3v5, XcmVersionedLocation, Iek7ha36da9mf5, I4h8nkgupb7obf, Ieunmbb5rijnk8, I1c6pg3s04ce55, Iet710s889rns7, I35p85j063s0il, Id5qsstfl1fkb3, I3ii6nera7pkr8 } from "./common-types";
type AnonymousEnum<T extends {}> = T & {
__anonymous: true;
};
type MyTuple<T> = [T, ...T[]];
type SeparateUndefined<T> = undefined extends T ? undefined | Exclude<T, undefined> : T;
type Anonymize<T> = SeparateUndefined<T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum<any> ? T : T extends AnonymousEnum<infer V> ? Enum<V> : T extends MyTuple<any> ? {
[K in keyof T]: T[K];
} : T extends [] ? [] : T extends FixedSizeArray<infer L, infer T> ? number extends L ? Array<T> : FixedSizeArray<L, T> : {
[K in keyof T & string]: T[K];
}>;
type IStorage = {
System: {
/**
* The full account information for a particular account ID.
*/
Account: StorageDescriptor<[Key: SS58String], Anonymize<I5sesotjlssv2d>, 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<Iffmde3ekjedi9>, false, never>;
/**
* Total length (in bytes) for all extrinsics put together, for the current block.
*/
AllExtrinsicsLen: StorageDescriptor<[], number, true, never>;
/**
* Map of block numbers to block hashes.
*/
BlockHash: StorageDescriptor<[Key: number], SizedHex<32>, false, never>;
/**
* Extrinsics data for the current block (maps an extrinsic's index to its data).
*/
ExtrinsicData: StorageDescriptor<[Key: number], Uint8Array, false, never>;
/**
* The current block number being processed. Set by `execute_block`.
*/
Number: StorageDescriptor<[], number, false, never>;
/**
* Hash of the previous block.
*/
ParentHash: StorageDescriptor<[], SizedHex<32>, false, never>;
/**
* Digest of the current block, also part of the block header.
*/
Digest: StorageDescriptor<[], Anonymize<I4mddgoa69c0a2>, 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<I3gicjuq7v22fo>, false, never>;
/**
* The number of events in the `Events<T>` list.
*/
EventCount: StorageDescriptor<[], number, false, never>;
/**
* Mapping between a topic (represented by T::Hash) and a vector of indexes
* of events in the `<Events<T>>` 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<T>, 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: SizedHex<32>], Anonymize<I95g6i7ilua7lq>, false, never>;
/**
* Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
*/
LastRuntimeUpgrade: StorageDescriptor<[], Anonymize<Ieniouoqkq4icf>, 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<Ibgl04rn6nbfm6>, 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<I4q39t5hn830vp>, false, 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>;
};
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<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>
* }
* ```
*
* 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<I1q8tnt1cluu5j>, 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<I8ds64oj6581v0>, 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<Ia7pdug7cdsg8g>, false, never>;
/**
* Holds on account balances.
*/
Holds: StorageDescriptor<[Key: SS58String], Anonymize<I4sklc1tvo63k3>, false, never>;
/**
* Freeze locks on account balances.
*/
Freezes: StorageDescriptor<[Key: SS58String], Anonymize<I9bin2jc70qt6q>, false, never>;
};
MultiTransactionPayment: {
/**
* Account currency map
*/
AccountCurrencyMap: StorageDescriptor<[Key: SS58String], number, true, never>;
/**
* Curated list of currencies which fees can be paid mapped to corresponding fallback price
*/
AcceptedCurrencies: StorageDescriptor<[Key: number], bigint, true, never>;
/**
* Asset prices from the spot price provider or the fallback price if the price is not available. Updated at the beginning of every block.
*/
AcceptedCurrencyPrice: StorageDescriptor<[Key: number], bigint, true, never>;
/**
*/
TransactionCurrencyOverride: StorageDescriptor<[Key: SS58String], number, true, never>;
};
Identity: {
/**
* Information that is pertinent to identify the entity behind an account. First item is the
* registration, second is the account's primary username.
*
* TWOX-NOTE: OK ― `AccountId` is a secure hash.
*/
IdentityOf: StorageDescriptor<[Key: SS58String], Anonymize<I4ftk0glls7946>, true, never>;
/**
* Identifies the primary username of an account.
*/
UsernameOf: StorageDescriptor<[Key: SS58String], Uint8Array, true, never>;
/**
* The super-identity of an alternative "sub" identity together with its name, within that
* context. If the account is not some other account's sub-identity, then just `None`.
*/
SuperOf: StorageDescriptor<[Key: SS58String], Anonymize<I910puuahutflf>, true, never>;
/**
* Alternative "sub" identities of this account.
*
* The first item is the deposit, the second is a vector of the accounts.
*
* TWOX-NOTE: OK ― `AccountId` is a secure hash.
*/
SubsOf: StorageDescriptor<[Key: SS58String], Anonymize<I4nfjdef0ibh44>, false, never>;
/**
* The set of registrars. Not expected to get very big as can only be added through a
* special origin (likely a council motion).
*
* The index into this can be cast to `RegistrarIndex` to get a valid value.
*/
Registrars: StorageDescriptor<[], Anonymize<I74af64m08r6as>, false, never>;
/**
* A map of the accounts who are authorized to grant usernames.
*/
AuthorityOf: StorageDescriptor<[Key: Uint8Array], Anonymize<Ic8ann3kre6vdm>, true, never>;
/**
* Reverse lookup from `username` to the `AccountId` that has registered it and the provider of
* the username. The `owner` value should be a key in the `UsernameOf` map, but it may not if
* the user has cleared their username or it has been removed.
*
* Multiple usernames may map to the same `AccountId`, but `UsernameOf` will only map to one
* primary username.
*/
UsernameInfoOf: StorageDescriptor<[Key: Uint8Array], Anonymize<I1j72qfgdejqsv>, true, never>;
/**
* Usernames that an authority has granted, but that the account controller has not confirmed
* that they want it. Used primarily in cases where the `AccountId` cannot provide a signature
* because they are a pure proxy, multisig, etc. In order to confirm it, they should call
* [accept_username](`Call::accept_username`).
*
* First tuple item is the account and second is the acceptance deadline.
*/
PendingUsernames: StorageDescriptor<[Key: Uint8Array], Anonymize<I60biiepd74113>, true, never>;
/**
* Usernames for which the authority that granted them has started the removal process by
* unbinding them. Each unbinding username maps to its grace period expiry, which is the first
* block in which the username could be deleted through a
* [remove_username](`Call::remove_username`) call.
*/
UnbindingUsernames: StorageDescriptor<[Key: Uint8Array], number, true, never>;
};
Democracy: {
/**
* The number of (public) proposals that have been made so far.
*/
PublicPropCount: StorageDescriptor<[], number, false, never>;
/**
* The public proposals. Unsorted. The second item is the proposal.
*/
PublicProps: StorageDescriptor<[], Anonymize<I6mhebgj62g585>, false, never>;
/**
* Those who have locked a deposit.
*
* TWOX-NOTE: Safe, as increasing integer keys are safe.
*/
DepositOf: StorageDescriptor<[Key: number], Anonymize<I3vhcedhm4hpvm>, true, never>;
/**
* The next free referendum index, aka the number of referenda started so far.
*/
ReferendumCount: StorageDescriptor<[], number, false, never>;
/**
* The lowest referendum index representing an unbaked referendum. Equal to
* `ReferendumCount` if there isn't a unbaked referendum.
*/
LowestUnbaked: StorageDescriptor<[], number, false, never>;
/**
* Information concerning any given referendum.
*
* TWOX-NOTE: SAFE as indexes are not under an attacker’s control.
*/
ReferendumInfoOf: StorageDescriptor<[Key: number], Anonymize<I526daka7j7b17>, true, never>;
/**
* All votes for a particular voter. We store the balance for the number of votes that we
* have recorded. The second item is the total amount of delegations, that will be added.
*
* TWOX-NOTE: SAFE as `AccountId`s are crypto hashes anyway.
*/
VotingOf: StorageDescriptor<[Key: SS58String], Anonymize<Ifanv2kvm586s4>, false, never>;
/**
* True if the last referendum tabled was submitted externally. False if it was a public
* proposal.
*/
LastTabledWasExternal: StorageDescriptor<[], boolean, false, never>;
/**
* The referendum to be tabled whenever it would be valid to table an external proposal.
* This happens when a referendum needs to be tabled and one of two conditions are met:
* - `LastTabledWasExternal` is `false`; or
* - `PublicProps` is empty.
*/
NextExternal: StorageDescriptor<[], Anonymize<I5rsgtofmn5lli>, true, never>;
/**
* A record of who vetoed what. Maps proposal hash to a possible existent block number
* (until when it may not be resubmitted) and who vetoed it.
*/
Blacklist: StorageDescriptor<[Key: SizedHex<32>], Anonymize<Idned7t7knml6b>, true, never>;
/**
* Record of all proposals that have been subject to emergency cancellation.
*/
Cancellations: StorageDescriptor<[Key: SizedHex<32>], boolean, false, never>;
/**
* General information concerning any proposal or referendum.
* The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON
* dump or IPFS hash of a JSON file.
*
* Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)
* large preimages.
*/
MetadataOf: StorageDescriptor<[Key: Anonymize<I2itl2k1j2q8nf>], SizedHex<32>, true, never>;
};
Proxy: {
/**
* The set of account proxies. Maps the account which has delegated to the accounts
* which are being delegated to, together with the amount held on deposit.
*/
Proxies: StorageDescriptor<[Key: SS58String], Anonymize<Iegjdtqhbb6qh9>, false, never>;
/**
* The announcements made by the proxy (key).
*/
Announcements: StorageDescriptor<[Key: SS58String], Anonymize<I9p9lq3rej5bhc>, false, never>;
};
Multisig: {
/**
* The set of open multisig operations.
*/
Multisigs: StorageDescriptor<Anonymize<I8uo3fpd3bcc6f>, Anonymize<Iag146hmjgqfgj>, true, never>;
};
Uniques: {
/**
* The items held by any given account; set out this way so that items owned by a single
* account can be enumerated.
*/
Account: StorageDescriptor<Anonymize<Ic3orq32is6lrl>, null, true, never>;
};
ConvictionVoting: {
/**
* All voting for a particular voter in a particular voting class. We store the balance for the
* number of votes that we have recorded.
*/
VotingFor: StorageDescriptor<Anonymize<I6ouflveob4eli>, ConvictionVotingVoteVoting, false, never>;
/**
* The voting classes which have a non-zero lock requirement and the lock amounts which they
* require. The actual amount locked on behalf of this pallet should always be the maximum of
* this list.
*/
ClassLocksFor: StorageDescriptor<[Key: SS58String], Anonymize<If9jidduiuq7vv>, false, never>;
};
Referenda: {
/**
* The next free referendum index, aka the number of referenda started so far.
*/
ReferendumCount: StorageDescriptor<[], number, false, never>;
/**
* Information concerning any given referendum.
*/
ReferendumInfoFor: StorageDescriptor<[Key: number], Anonymize<I3tt16iedrf9nu>, true, never>;
/**
* The sorted list of referenda ready to be decided but not yet being decided, ordered by
* conviction-weighted approvals.
*
* This should be empty if `DecidingCount` is less than `TrackInfo::max_deciding`.
*/
TrackQueue: StorageDescriptor<[Key: number], Anonymize<If9jidduiuq7vv>, false, never>;
/**
* The number of referenda being decided currently.
*/
DecidingCount: StorageDescriptor<[Key: number], number, false, never>;
/**
* The metadata is a general information concerning the referendum.
* The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON
* dump or IPFS hash of a JSON file.
*
* Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)
* large preimages.
*/
MetadataOf: StorageDescriptor<[Key: number], SizedHex<32>, true, never>;
};
AssetRegistry: {
/**
* Details of an asset.
*/
Assets: StorageDescriptor<[Key: number], Anonymize<Ifj0li5nn5unet>, true, never>;
/**
* Next available asset id. This is sequential id assigned for each new registered asset.
*/
NextAssetId: StorageDescriptor<[], number, false, never>;
/**
* Mapping between asset name and asset id.
*/
AssetIds: StorageDescriptor<[Key: Uint8Array], number, true, never>;
/**
* Native location of an asset.
*/
AssetLocations: StorageDescriptor<[Key: number], Anonymize<If9iqq7i64mur8>, true, never>;
/**
* Non-native assets which transfer is banned.
*/
BannedAssets: StorageDescriptor<[Key: number], null, true, never>;
/**
* Local asset for native location.
*/
LocationAssets: StorageDescriptor<[Key: Anonymize<If9iqq7i64mur8>], number, true, never>;
/**
* Number of accounts that paid existential deposits for insufficient assets.
* This storage is used by `SufficiencyCheck`.
*/
ExistentialDepositCounter: StorageDescriptor<[], bigint, false, never>;
};
Omnipool: {
/**
* State of an asset in the omnipool
*/
Assets: StorageDescriptor<[Key: number], Anonymize<I8ikpj86u2na1q>, true, never>;
/**
* Tradable state of hub asset.
*/
HubAssetTradability: StorageDescriptor<[], number, false, never>;
/**
* LP positions. Maps NFT instance id to corresponding position
*/
Positions: StorageDescriptor<[Key: bigint], Anonymize<Icbsch55a85u5u>, true, never>;
/**
* Position ids sequencer
*/
NextPositionId: StorageDescriptor<[], bigint, false, never>;
/**
* Global slip fee configuration.
* `None` = slip fees disabled (default). `Some(config)` = enabled.
* Set via `set_slip_fee` extrinsic (governance).
*/
SlipFee: StorageDescriptor<[], number, true, never>;
/**
* Snapshot of each asset's hub_reserve at the start of the current block.
* Lazily populated on first trade per asset per block, cleared in on_finalize.
*/
SlipFeeHubReserveAtBlockStart: StorageDescriptor<[Key: number], bigint, true, never>;
/**
* Cumulative net hub asset delta per asset in the current block.
* Negative = net hub asset outflow, positive = net hub asset inflow.
* Cleared in on_finalize.
*/
SlipFeeDelta: StorageDescriptor<[Key: number], Anonymize<Ib9d9r6ft4gk7o>, false, never>;
};
OmnipoolWarehouseLM: {
/**
* Id sequencer for `GlobalFarm` and `YieldFarm`.
*/
FarmSequencer: StorageDescriptor<[], number, false, never>;
/**
*/
DepositSequencer: StorageDescriptor<[], bigint, false, never>;
/**
*/
GlobalFarm: StorageDescriptor<[Key: number], Anonymize<I5ugnv0dol8v8t>, true, never>;
/**
* Yield farm details.
*/
YieldFarm: StorageDescriptor<Anonymize<Ielgh4t8o7rcvt>, Anonymize<I1ksaufim9dq1c>, true, never>;
/**
* Deposit details.
*/
Deposit: StorageDescriptor<[Key: bigint], Anonymize<I3rvqhkck00laj>, true, never>;
/**
* Active(farms able to receive LP shares deposits) yield farms.
*/
ActiveYieldFarm: StorageDescriptor<Anonymize<I9jd27rnpm8ttv>, number, true, never>;
};
OmnipoolLiquidityMining: {
/**
* Map of omnipool position's ids to LM's deposit ids.
*/
OmniPositionId: StorageDescriptor<[Key: bigint], bigint, true, never>;
};
OTC: {
/**
* ID sequencer for Orders
*/
NextOrderId: StorageDescriptor<[], number, false, never>;
/**
*/
Orders: StorageDescriptor<[Key: number], Anonymize<I7bcpl5g2rcql5>, true, never>;
};
CircuitBreaker: {
/**
* Trade volume limits of assets set by set_trade_volume_limit.
* If not set, returns the default limit.
*/
TradeVolumeLimitPerAsset: StorageDescriptor<[Key: number], Anonymize<I9jd27rnpm8ttv>, false, never>;
/**
* Trade volumes per asset
*/
AllowedTradeVolumeLimitPerAsset: StorageDescriptor<[Key: number], Anonymize<I4vdvk2616mp4t>, true, never>;
/**
* Liquidity limits of assets for adding liquidity.
* If not set, returns the default limit.
*/
LiquidityAddLimitPerAsset: StorageDescriptor<[Key: number], Anonymize<Iep7au1720bm0e>, false, never>;
/**
* Add liquidity volumes per asset
*/
AllowedAddLiquidityAmountPerAsset: StorageDescriptor<[Key: number], Anonymize<I48olja7kd2ijk>, true, never>;
/**
*/
AssetLockdownState: StorageDescriptor<[Key: number], Anonymize<I94ue2k0qjjmh>, true, never>;
/**
* Liquidity limits of assets for removing liquidity.
* If not set, returns the default limit.
*/
LiquidityRemoveLimitPerAsset: StorageDescriptor<[Key: number], Anonymize<Iep7au1720bm0e>, false, never>;
/**
* Remove liquidity volumes per asset
*/
AllowedRemoveLiquidityAmountPerAsset: StorageDescriptor<[Key: number], Anonymize<I48olja7kd2ijk>, true, never>;
/**
* Configured global withdraw limit parameters
*/
GlobalWithdrawLimitConfig: StorageDescriptor<[], Anonymize<Icmar3g4068bt5>, true, never>;
/**
* Tuple of (current_accumulator_in_ref, last_update_timestamp_ms)
*/
WithdrawLimitAccumulator: StorageDescriptor<[], Anonymize<I2j729bmgsdiuo>, false, never>;
/**
* If some, global lockdown is active until this timestamp.
*/
WithdrawLockdownUntil: StorageDescriptor<[], bigint, true, never>;
/**
* A map of accounts that are considered egress sinks.
*/
EgressAccounts: StorageDescriptor<[Key: SS58String], null, true, never>;
/**
* When set to true, egress accounting is skipped.
*/
IgnoreWithdrawLimit: StorageDescriptor<[], boolean, false, never>;
/**
* Overrides for global asset categorization.
*/
GlobalAssetOverrides: StorageDescriptor<[Key: number], Anonymize<I5bbnmrss3h025>, true, never>;
/**
* Per-XCM-message buffer of (withdrawn_hdx, deposited_hdx).
* None means buffer is inactive (not inside XCM message processing).
*/
XcmEgressBuffer: StorageDescriptor<[], Anonymize<I200n1ov5tbcvr>, true, never>;
};
DynamicFees: {
/**
* Stores last calculated fee of an asset and block number in which it was changed..
* Stored as (Asset fee, Protocol fee, Block number)
*/
AssetFee: StorageDescriptor<[Key: number], Anonymize<Ibn3i0ad6beo5l>, true, never>;
/**
* Stores per-asset fee configuration (Fixed or Dynamic)
*/
AssetFeeConfiguration: StorageDescriptor<[Key: number], Anonymize<I5aq7tv9lofc3v>, true, never>;
};
Staking: {
/**
* Global staking state.
*/
Staking: StorageDescriptor<[], Anonymize<I10uqvdcdcld3o>, false, never>;
/**
* User's position state.
*/
Positions: StorageDescriptor<[Key: bigint], Anonymize<I3fgr93o42d9hi>, true, never>;
/**
* Position ids sequencer.
*/
NextPositionId: StorageDescriptor<[], bigint, false, never>;
/**
* List of position votes.
*/
Votes: StorageDescriptor<[Key: bigint], Anonymize<Ihjc2vmjfhsmq>, false, never>;
/**
* List of processed vote. Used to determine if the vote should be locked in case of voting not in favor.
*/
VotesRewarded: StorageDescriptor<Anonymize<I6ouflveob4eli>, Anonymize<I663kh18bno0fo>, true, never>;
/**
* Legacy storage! - Used to handle democracy votes until democracy pallet is fully removed.
*/
PositionVotes: StorageDescriptor<[Key: bigint], Anonymize<Ihjc2vmjfhsmq>, false, never>;
/**
* Legacy storage! - Used to handle democracy processed votes until democracy pallet is fully removed.
*/
ProcessedVotes: StorageDescriptor<Anonymize<I6ouflveob4eli>, Anonymize<I663kh18bno0fo>, true, never>;
/**
* Block number when we switched to 6 sec. blocks.
*/
SixSecBlocksSince: StorageDescriptor<[], number, false, never>;
};
Stableswap: {
/**
* Existing pools
*/
Pools: StorageDescriptor<[Key: number], Anonymize<I1p5pqg6bllgtl>, true, never>;
/**
* Pool peg info.
*/
PoolPegs: StorageDescriptor<[Key: number], Anonymize<Ier4eivhqndrf3>, true, never>;
/**
* Tradability state of pool assets.
*/
AssetTradability: StorageDescriptor<Anonymize<I9jd27rnpm8ttv>, number, false, never>;
/**
* Temporary pool state storage. Used to save a state of pool in a single block.
*/
PoolSnapshots: StorageDescriptor<[Key: number], Anonymize<I6tni6burv9dng>, true, never>;
/**
* Temporary pool's trade fee for current block.
*/
BlockFee: StorageDescriptor<[Key: number], number, true, never>;
};
Bonds: {
/**
* Registered bond ids.
* Maps (underlying asset ID, maturity) -> bond ID
*/
BondIds: StorageDescriptor<[Key: Anonymize<I4ojmnsk1dchql>], number, true, never>;
/**
* Registered bonds.
* Maps bond ID -> (underlying asset ID, maturity)
*/
Bonds: StorageDescriptor<[Key: number], Anonymize<I4ojmnsk1dchql>, true, never>;
};
LBP: {
/**
* Details of a pool.
*/
PoolData: StorageDescriptor<[Key: SS58String], Anonymize<Iesq88051ch8ht>, true, never>;
/**
* Storage used for tracking existing fee collectors
* Not more than one fee collector per asset possible
*/
FeeCollectorWithAsset: StorageDescriptor<Anonymize<I6ouflveob4eli>, boolean, false, never>;
};
XYK: {
/**
* Asset id storage for shared pool tokens
*/
ShareToken: StorageDescriptor<[Key: SS58String], number, false, never>;
/**
* Total liquidity in a pool.
*/
TotalLiquidity: StorageDescriptor<[Key: SS58String], bigint, false, never>;
/**
* Asset pair in a pool.
*/
PoolAssets: StorageDescriptor<[Key: SS58String], Anonymize<I9jd27rnpm8ttv>, true, never>;
};
Referrals: {
/**
* Referral codes
* Maps a referral code to an account.
*/
ReferralCodes: StorageDescriptor<[Key: Uint8Array], SS58String, true, never>;
/**
* Referral accounts
* Maps an account to a referral code.
*/
ReferralAccounts: StorageDescriptor<[Key: SS58String], Uint8Array, true, never>;
/**
* Linked accounts.
* Maps an account to a referral account.
*/
LinkedAccounts: StorageDescriptor<[Key: SS58String], SS58String, true, never>;
/**
* Shares of a referral account
*/
ReferrerShares: StorageDescriptor<[Key: SS58String], bigint, false, never>;
/**
* Shares of a trader account
*/
TraderShares: StorageDescriptor<[Key: SS58String], bigint, false, never>;
/**
* Total share issuance.
*/
TotalShares: StorageDescriptor<[], bigint, false, never>;
/**
* Referer level and total accumulated rewards over time.
* Maps referrer account to (Level, Balance). Level indicates current rewards and Balance is used to unlock next level.
* Dev note: we use OptionQuery here because this helps to easily determine that an account if referrer account.
*/
Referrer: StorageDescriptor<[Key: SS58String], Anonymize<I9qpa0evftgoo5>, true, never>;
/**
* Asset fee distribution rewards information.
* Maps (asset_id, level) to asset reward percentages.
*/
AssetRewards: StorageDescriptor<Anonymize<I1stghsu756nk9>, Anonymize<I4qc61lpfqml75>, true, never>;
/**
* Information about assets that are currently in the rewards pot.
* Used to easily determine list of assets that need to be converted.
*/
PendingConversions: StorageDescriptor<[Key: number], null, true, never>;
/**
* Counter for the related counted storage map
*/
CounterForPendingConversions: StorageDescriptor<[], number, false, never>;
};
HSM: {
/**
* List of approved assets that Hollar can be purchased with
*
* This storage maps asset IDs to their collateral configuration information.
* Only assets in this map can be used to mint or redeem Hollar through HSM.
* Each collateral has specific parameters controlling its usage in the HSM mechanism.
*/
Collaterals: StorageDescriptor<[Key: number], Anonymize<Idqn78enhf4jrq>, true, never>;
/**
* Amount of Hollar bought with an asset in a single block
*
* This storage tracks how much Hollar has been bought back by HSM for each collateral
* asset within the current block. This is used to enforce rate limiting on Hollar redemptions.
* Values are reset to zero at the end of each block in on_finalize.
*/
HollarAmountReceived: StorageDescriptor<[Key: number], bigint, false, never>;
/**
* Address of the flash loan receiver.
*/
FlashMinter: StorageDescriptor<[], SizedHex<20>, true, never>;
};
Tokens: {
/**
* The total issuance of a token type.
*/
TotalIssuance: StorageDescriptor<[Key: number], bigint, false, never>;
/**
* Any liquidity locks of a token type under an account.
* NOTE: Should only be accessed when setting, changing and freeing a lock.
*/
Locks: StorageDescriptor<Anonymize<I6ouflveob4eli>, Anonymize<Ia7pdug7cdsg8g>, false, never>;
/**
* The balance of a token type under an account.
*
* NOTE: If the total is ever zero, decrease account ref account.
*
* NOTE: This is only used in the case that this module is used to store
* balances.
*/
Accounts: StorageDescriptor<Anonymize<I6ouflveob4eli>, Anonymize<Ic02kut0350gb0>, false, never>;
/**
* Named reserves on some account balances.
*/
Reserves: StorageDescriptor<Anonymize<I6ouflveob4eli>, Anonymize<Ia7pdug7cdsg8g>, false, never>;
};
Ethereum: {
/**
* Mapping from transaction index to transaction in the current building block.
*/
Pending: StorageDescriptor<[Key: number], Anonymize<Ic3l568el19b24>, true, never>;
/**
* Counter for the related counted storage map
*/
CounterForPending: StorageDescriptor<[], number, false, never>;
/**
* The current Ethereum block.
*/
CurrentBlock: StorageDescriptor<[], Anonymize<Ib0hfhkohlekcj>, true, never>;
/**
* The current Ethereum receipts.
*/
CurrentReceipts: StorageDescriptor<[], Anonymize<I32lgu058i52q9>, true, never>;
/**
* The current transaction statuses.
*/
CurrentTransactionStatuses: StorageDescriptor<[], Anonymize<Ie7atdsih6q14b>, true, never>;
/**
*/
BlockHash: StorageDescriptor<[Key: Anonymize<I4totqt881mlti>], SizedHex<32>, false, never>;
};
XYKWarehouseLM: {
/**
* Id sequencer for `GlobalFarm` and `YieldFarm`.
*/
FarmSequencer: StorageDescriptor<[], number, false, never>;
/**
*/
DepositSequencer: StorageDescriptor<[], bigint, false, never>;
/**
*/
GlobalFarm: StorageDescriptor<[Key: number], Anonymize<I5ugnv0dol8v8t>, true, never>;
/**
* Yield farm details.
*/
YieldFarm: StorageDescriptor<Anonymize<Id32h28hjj1tch>, Anonymize<I1ksaufim9dq1c>, true, never>;
/**
* Deposit details.
*/
Deposit: StorageDescriptor<[Key: bigint], Anonymize<I66gvo4ilpv28i>, true, never>;
/**
* Active(farms able to receive LP shares deposits) yield farms.
*/
ActiveYieldFarm: StorageDescriptor<Anonymize<I6ouflveob4eli>, number, true, never>;
};
ParachainSystem: {
/**
* The [`PersistedValidationData`] set for this block.
* This value is expected to be set only once per block and it's never stored
* in the trie.
*/
ValidationData: StorageDescriptor<[], Anonymize<Ifn6q3equiq9qi>, true, never>;
};
EmaOracle: {
/**
* Accumulator for oracle data in current block that will be recorded at the end of the block.
*/
Accumulator: StorageDescriptor<[], Anonymize<I8kbiofpboejrm>, false, never>;
/**
* Oracle storage keyed by data source, involved asset ids and the period length of the oracle.
*
* Stores the data entry as well as the block number when the oracle was first initialized.
*/
Oracles: StorageDescriptor<Anonymize<I1os9h4ivict7u>, Anonymize<I9ae1049tiuvhb>, true, never>;
/**
* Assets that are whitelisted and tracked by the pallet.
*/
WhitelistedAssets: StorageDescriptor<[], Anonymize<Isa48262v9oqu>, false, never>;
};
};
type ICalls = {
MultiTransactionPayment: {
/**
* Set selected currency for given account.
*
* This allows to set a currency for an account in which all transaction fees will be paid.
* Account balance cannot be zero.
*
* In case of sufficient asset, the chosen currency must be in the list of accepted currencies
* In case of insufficient asset, the chosen currency must have a XYK pool with DOT
*
* When currency is set, fixed fee is withdrawn from the account to pay for the currency change
*
* EVM accounts are now allowed to change thier payment currency.
*
* Emits `CurrencySet` event when successful.
*/
set_currency: TxDescriptor<Anonymize<Ic1e6uvbf8ado3>>;
/**
* Add a currency to the list of accepted currencies.
*
* Only member can perform this action.
*
* Currency must not be already accepted. Core asset id cannot be explicitly added.
*
* Emits `CurrencyAdded` event when successful.
*/
add_currency: TxDescriptor<Anonymize<Ie7oqvfdar8r2>>;
/**
* Remove currency from the list of supported currencies
* Only selected members can perform this action
*
* Core asset cannot be removed.
*
* Emits `CurrencyRemoved` when successful.
*/
remove_currency: TxDescriptor<Anonymize<Ic1e6uvbf8ado3>>;
/**
* Reset currency of the specified account to HDX.
* If the account is EVM account, the payment currency is reset to WETH.
* Only selected members can perform this action.
*
* Emits `CurrencySet` when successful.
*/
reset_payment_currency: TxDescriptor<Anonymize<I6v8sm60vvkmk7>>;
/**
* Dispatch EVM permit.
* The main purpose of this function is to allow EVM accounts to pay for the transaction fee in non-native currency
* by allowing them to self-dispatch pre-signed permit.
* The EVM fee is paid in the currency set for the account.
*/
dispatch_permit: TxDescriptor<Anonymize<I92pum5p0t4pat>>;
};
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<Anonymize<Ievdsibhthdgfm>>;
/**
* 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<Anonymize<I6uavo5oia2vma>>;
/**
* 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<Anonymize<Ievdsibhthdgfm>>;
/**
* Dispatches a function call with a provided origin.
*
* The dispatch origin for this call must be _Root_.
*
* ## Complexity
* - O(1).
*/
dispatch_as: TxDescriptor<Anonymize<I7cibfirq2tgp9>>;
/**
* 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<Anonymize<Ievdsibhthdgfm>>;
/**
* 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<Anonymize<I3orh1nv01rrjo>>;
/**
* 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<Anonymize<I6h476hpq98c65>>;
/**
* 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<Anonymize<I7cibfirq2tgp9>>;
};
Democracy: {
/**
* Propose a sensitive action to be taken.
*
* The dispatch origin of this call must be _Signed_ and the sender must
* have funds to cover the deposit.
*
* - `proposal_hash`: The hash of the proposal preimage.
* - `value`: The amount of deposit (must be at least `MinimumDeposit`).
*
* Emits `Proposed`.
*/
propose: TxDescriptor<Anonymize<I1moso5oagpiea>>;
/**
* Signals ag