import { StorageDescriptor, PlainDescriptor, TxDescriptor, RuntimeDescriptor, Enum, ApisFromDef, QueryFromPalletsDef, TxFromPalletsDef, EventsFromPalletsDef, ErrorsFromPalletsDef, ConstFromPalletsDef, ViewFnsFromPalletsDef, SS58String, SizedHex, FixedSizeArray } from "polkadot-api"; import type { I5sesotjlssv2d, Iffmde3ekjedi9, I4mddgoa69c0a2, I3507nrcg5is88, 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, I4nolc7nml8478, Ifj0li5nn5unet, If9iqq7i64mur8, I8ikpj86u2na1q, Icbsch55a85u5u, Ib9d9r6ft4gk7o, I5ugnv0dol8v8t, I1ksaufim9dq1c, Ielgh4t8o7rcvt, I3rvqhkck00laj, I9jd27rnpm8ttv, I7bcpl5g2rcql5, I4vdvk2616mp4t, Iep7au1720bm0e, I48olja7kd2ijk, I94ue2k0qjjmh, Icmar3g4068bt5, I2j729bmgsdiuo, I5bbnmrss3h025, 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, I83n80gkbnfjcq, Ivg0aodu5nhb6, I2tjadu6fllihs, I7h55cudoh6rv, I67f2i9uf47j6h, I1moso5oagpiea, Ibeb4n9vpjefp3, Id7murq9s9fg6h, Ied9mja4bq7va8, I4f7jul8ljs54r, I5agg650597e49, I2ev73t79f46tb, Iab64mce6q91i, I14p0q0qs0fqbj, I666bl2fqjkejo, I7ji3jng252el9, I3v9h9f3mpm1l8, I9mnj4k4u8ls2c, I2kt2u1flctk2q, I9t64o1u41j66q, I2e1ekg17a2uj2, I9uff8o8g5b5av, I1acluqiqlacck, Idkqesere66fs7, Ifs54vj2idl9k4, I38hmfa91pqd9j, I1mu45rfgmpr4l, I17sjlq9lhpktt, Ideaemvoneh309, I3d9o9d7epp66v, I6lqh1vgb4mcja, Idnsr2pndm36h0, Itcpv4hqecjfj, I8steo882k7qns, I9qtj66dgng975, I5f178ab6b89t3, Iduerupfbc8ruc, Ieg173e4f63n9e, Icbccs0ug47ilf, I1d2d27jp1ajkt, Ida2ijjar0n0j3, Ing3etrevsfg0, Ietsl92b11kilg, 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, Iabpgqcjikia83, Icgljjb6j82uhn, I4g15ko4u63fja, If08sfhqn8ujfr, Ic4rgfgksgmm3e, I3dj14b7k3rkm5, Ic5egmm215ml6k, Iac0gjj1qrkv79, I2jfe0buku0po7, I5fvdd841odbi3, I35vouom6s9r2, Ie6kgk6f04rsvk, Ifgqf2rskq94om, Itom7fk49o0c9, Ie30stbbeaul1o, I4arjljr6dpflb, I7aold6s47n103, Ic952bubvq4k7d, Ihfphjolmsqq1, Iftvbctbo05fu4, XcmVersionedXcm, Ic0c3req3mlc1l, XcmVersionedAssetId, I7ocn4njqde3v5, XcmVersionedLocation, Iek7ha36da9mf5, Idf0rsk73ceelk, Idcck6gqttg3r0, I87tn6noreecq1, Ibila1h2m0eu11, I35p85j063s0il, Id5qsstfl1fkb3, I3ii6nera7pkr8 } from "./common-types"; type AnonymousEnum = T & { __anonymous: true; }; type MyTuple = [T, ...T[]]; type SeparateUndefined = undefined extends T ? undefined | Exclude : T; type Anonymize = SeparateUndefined ? 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 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, 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: SizedHex<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>; }; 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, 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>; }; 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, 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, 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, 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, false, never>; /** * A map of the accounts who are authorized to grant usernames. */ AuthorityOf: StorageDescriptor<[Key: Uint8Array], Anonymize, 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, 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, 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, false, never>; /** * Those who have locked a deposit. * * TWOX-NOTE: Safe, as increasing integer keys are safe. */ DepositOf: StorageDescriptor<[Key: number], Anonymize, 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, 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, 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, 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, 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], 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, false, never>; /** * The announcements made by the proxy (key). */ Announcements: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; }; Multisig: { /** * The set of open multisig operations. */ Multisigs: StorageDescriptor, Anonymize, 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, 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, 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, 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, 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, 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, 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, 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], 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, 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, 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, false, never>; }; OmnipoolWarehouseLM: { /** * Id sequencer for `GlobalFarm` and `YieldFarm`. */ FarmSequencer: StorageDescriptor<[], number, false, never>; /** */ DepositSequencer: StorageDescriptor<[], bigint, false, never>; /** */ GlobalFarm: StorageDescriptor<[Key: number], Anonymize, true, never>; /** * Yield farm details. */ YieldFarm: StorageDescriptor, Anonymize, true, never>; /** * Deposit details. */ Deposit: StorageDescriptor<[Key: bigint], Anonymize, true, never>; /** * Active(farms able to receive LP shares deposits) yield farms. */ ActiveYieldFarm: StorageDescriptor, 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, 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, false, never>; /** * Trade volumes per asset */ AllowedTradeVolumeLimitPerAsset: StorageDescriptor<[Key: number], Anonymize, true, never>; /** * Liquidity limits of assets for adding liquidity. * If not set, returns the default limit. */ LiquidityAddLimitPerAsset: StorageDescriptor<[Key: number], Anonymize, false, never>; /** * Add liquidity volumes per asset */ AllowedAddLiquidityAmountPerAsset: StorageDescriptor<[Key: number], Anonymize, true, never>; /** */ AssetLockdownState: StorageDescriptor<[Key: number], Anonymize, true, never>; /** * Liquidity limits of assets for removing liquidity. * If not set, returns the default limit. */ LiquidityRemoveLimitPerAsset: StorageDescriptor<[Key: number], Anonymize, false, never>; /** * Remove liquidity volumes per asset */ AllowedRemoveLiquidityAmountPerAsset: StorageDescriptor<[Key: number], Anonymize, true, never>; /** * Configured global withdraw limit parameters */ GlobalWithdrawLimitConfig: StorageDescriptor<[], Anonymize, true, never>; /** * Tuple of (current_accumulator_in_ref, last_update_timestamp_ms) */ WithdrawLimitAccumulator: StorageDescriptor<[], Anonymize, 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, 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, true, never>; /** * Stores per-asset fee configuration (Fixed or Dynamic) */ AssetFeeConfiguration: StorageDescriptor<[Key: number], Anonymize, true, never>; }; Staking: { /** * Global staking state. */ Staking: StorageDescriptor<[], Anonymize, false, never>; /** * User's position state. */ Positions: StorageDescriptor<[Key: bigint], Anonymize, true, never>; /** * Position ids sequencer. */ NextPositionId: StorageDescriptor<[], bigint, false, never>; /** * List of position votes. */ Votes: StorageDescriptor<[Key: bigint], Anonymize, 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, true, never>; /** * Legacy storage! - Used to handle democracy votes until democracy pallet is fully removed. */ PositionVotes: StorageDescriptor<[Key: bigint], Anonymize, false, never>; /** * Legacy storage! - Used to handle democracy processed votes until democracy pallet is fully removed. */ ProcessedVotes: StorageDescriptor, Anonymize, true, never>; /** * Block number when we switched to 6 sec. blocks. */ SixSecBlocksSince: StorageDescriptor<[], number, false, never>; }; Stableswap: { /** * Existing pools */ Pools: StorageDescriptor<[Key: number], Anonymize, true, never>; /** * Pool peg info. */ PoolPegs: StorageDescriptor<[Key: number], Anonymize, true, never>; /** * Tradability state of pool assets. */ AssetTradability: StorageDescriptor, number, false, never>; /** * Temporary pool state storage. Used to save a state of pool in a single block. */ PoolSnapshots: StorageDescriptor<[Key: number], Anonymize, 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], number, true, never>; /** * Registered bonds. * Maps bond ID -> (underlying asset ID, maturity) */ Bonds: StorageDescriptor<[Key: number], Anonymize, true, never>; }; LBP: { /** * Details of a pool. */ PoolData: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; /** * Storage used for tracking existing fee collectors * Not more than one fee collector per asset possible */ FeeCollectorWithAsset: StorageDescriptor, 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, 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, true, never>; /** * Asset fee distribution rewards information. * Maps (asset_id, level) to asset reward percentages. */ AssetRewards: StorageDescriptor, Anonymize, 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, 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, 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, false, never>; /** * Named reserves on some account balances. */ Reserves: StorageDescriptor, Anonymize, false, never>; }; Ethereum: { /** * Mapping from transaction index to transaction in the current building block. */ Pending: StorageDescriptor<[Key: number], Anonymize, true, never>; /** * Counter for the related counted storage map */ CounterForPending: StorageDescriptor<[], number, false, never>; /** * The current Ethereum block. */ CurrentBlock: StorageDescriptor<[], Anonymize, true, never>; /** * The current Ethereum receipts. */ CurrentReceipts: StorageDescriptor<[], Anonymize, true, never>; /** * The current transaction statuses. */ CurrentTransactionStatuses: StorageDescriptor<[], Anonymize, true, never>; /** */ BlockHash: StorageDescriptor<[Key: Anonymize], 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, true, never>; /** * Yield farm details. */ YieldFarm: StorageDescriptor, Anonymize, true, never>; /** * Deposit details. */ Deposit: StorageDescriptor<[Key: bigint], Anonymize, true, never>; /** * Active(farms able to receive LP shares deposits) yield farms. */ ActiveYieldFarm: StorageDescriptor, 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, true, never>; }; EmaOracle: { /** * Accumulator for oracle data in current block that will be recorded at the end of the block. */ Accumulator: StorageDescriptor<[], Anonymize, 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, true, never>; /** * Assets that are whitelisted and tracked by the pallet. */ WhitelistedAssets: StorageDescriptor<[], Anonymize, 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>; /** * 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>; /** * 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>; /** * 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>; /** * 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>; }; 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>; }; 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>; /** * Signals agreement with a particular proposal. * * The dispatch origin of this call must be _Signed_ and the sender * must have funds to cover the deposit, equal to the original deposit. * * - `proposal`: The index of the proposal to second. */ second: TxDescriptor>; /** * Vote in a referendum. If `vote.is_aye()`, the vote is to enact the proposal; * otherwise it is a vote to keep the status quo. * * The dispatch origin of this call must be _Signed_. * * - `ref_index`: The index of the referendum to vote for. * - `vote`: The vote configuration. */ vote: TxDescriptor>; /** * Schedule an emergency cancellation of a referendum. Cannot happen twice to the same * referendum. * * The dispatch origin of this call must be `CancellationOrigin`. * * -`ref_index`: The index of the referendum to cancel. * * Weight: `O(1)`. */ emergency_cancel: TxDescriptor>; /** * Schedule a referendum to be tabled once it is legal to schedule an external * referendum. * * The dispatch origin of this call must be `ExternalOrigin`. * * - `proposal_hash`: The preimage hash of the proposal. */ external_propose: TxDescriptor>; /** * Schedule a majority-carries referendum to be tabled next once it is legal to schedule * an external referendum. * * The dispatch of this call must be `ExternalMajorityOrigin`. * * - `proposal_hash`: The preimage hash of the proposal. * * Unlike `external_propose`, blacklisting has no effect on this and it may replace a * pre-scheduled `external_propose` call. * * Weight: `O(1)` */ external_propose_majority: TxDescriptor>; /** * Schedule a negative-turnout-bias referendum to be tabled next once it is legal to * schedule an external referendum. * * The dispatch of this call must be `ExternalDefaultOrigin`. * * - `proposal_hash`: The preimage hash of the proposal. * * Unlike `external_propose`, blacklisting has no effect on this and it may replace a * pre-scheduled `external_propose` call. * * Weight: `O(1)` */ external_propose_default: TxDescriptor>; /** * Schedule the currently externally-proposed majority-carries referendum to be tabled * immediately. If there is no externally-proposed referendum currently, or if there is one * but it is not a majority-carries referendum then it fails. * * The dispatch of this call must be `FastTrackOrigin`. * * - `proposal_hash`: The hash of the current external proposal. * - `voting_period`: The period that is allowed for voting on this proposal. Increased to * Must be always greater than zero. * For `FastTrackOrigin` must be equal or greater than `FastTrackVotingPeriod`. * - `delay`: The number of block after voting has ended in approval and this should be * enacted. This doesn't have a minimum amount. * * Emits `Started`. * * Weight: `O(1)` */ fast_track: TxDescriptor>; /** * Veto and blacklist the external proposal hash. * * The dispatch origin of this call must be `VetoOrigin`. * * - `proposal_hash`: The preimage hash of the proposal to veto and blacklist. * * Emits `Vetoed`. * * Weight: `O(V + log(V))` where V is number of `existing vetoers` */ veto_external: TxDescriptor>; /** * Remove a referendum. * * The dispatch origin of this call must be _Root_. * * - `ref_index`: The index of the referendum to cancel. * * # Weight: `O(1)`. */ cancel_referendum: TxDescriptor>; /** * Delegate the voting power (with some given conviction) of the sending account. * * The balance delegated is locked for as long as it's delegated, and thereafter for the * time appropriate for the conviction's lock period. * * The dispatch origin of this call must be _Signed_, and the signing account must either: * - be delegating already; or * - have no voting activity (if there is, then it will need to be removed/consolidated * through `reap_vote` or `unvote`). * * - `to`: The account whose voting the `target` account's voting power will follow. * - `conviction`: The conviction that will be attached to the delegated votes. When the * account is undelegated, the funds will be locked for the corresponding period. * - `balance`: The amount of the account's balance to be used in delegating. This must not * be more than the account's current balance. * * Emits `Delegated`. * * Weight: `O(R)` where R is the number of referendums the voter delegating to has * voted on. Weight is charged as if maximum votes. */ delegate: TxDescriptor>; /** * Undelegate the voting power of the sending account. * * Tokens may be unlocked following once an amount of time consistent with the lock period * of the conviction with which the delegation was issued. * * The dispatch origin of this call must be _Signed_ and the signing account must be * currently delegating. * * Emits `Undelegated`. * * Weight: `O(R)` where R is the number of referendums the voter delegating to has * voted on. Weight is charged as if maximum votes. */ undelegate: TxDescriptor; /** * Clears all public proposals. * * The dispatch origin of this call must be _Root_. * * Weight: `O(1)`. */ clear_public_proposals: TxDescriptor; /** * Unlock tokens that have an expired lock. * * The dispatch origin of this call must be _Signed_. * * - `target`: The account to remove the lock on. * * Weight: `O(R)` with R number of vote of target. */ unlock: TxDescriptor>; /** * Remove a vote for a referendum. * * If: * - the referendum was cancelled, or * - the referendum is ongoing, or * - the referendum has ended such that * - the vote of the account was in opposition to the result; or * - there was no conviction to the account's vote; or * - the account made a split vote * ...then the vote is removed cleanly and a following call to `unlock` may result in more * funds being available. * * If, however, the referendum has ended and: * - it finished corresponding to the vote of the account, and * - the account made a standard vote with conviction, and * - the lock period of the conviction is not over * ...then the lock will be aggregated into the overall account's lock, which may involve * *overlocking* (where the two locks are combined into a single lock that is the maximum * of both the amount locked and the time is it locked for). * * The dispatch origin of this call must be _Signed_, and the signer must have a vote * registered for referendum `index`. * * - `index`: The index of referendum of the vote to be removed. * * Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on. * Weight is calculated for the maximum number of vote. */ remove_vote: TxDescriptor>; /** * Remove a vote for a referendum. * * If the `target` is equal to the signer, then this function is exactly equivalent to * `remove_vote`. If not equal to the signer, then the vote must have expired, * either because the referendum was cancelled, because the voter lost the referendum or * because the conviction period is over. * * The dispatch origin of this call must be _Signed_. * * - `target`: The account of the vote to be removed; this account must have voted for * referendum `index`. * - `index`: The index of referendum of the vote to be removed. * * Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on. * Weight is calculated for the maximum number of vote. */ remove_other_vote: TxDescriptor>; /** * Permanently place a proposal into the blacklist. This prevents it from ever being * proposed again. * * If called on a queued public or external proposal, then this will result in it being * removed. If the `ref_index` supplied is an active referendum with the proposal hash, * then it will be cancelled. * * The dispatch origin of this call must be `BlacklistOrigin`. * * - `proposal_hash`: The proposal hash to blacklist permanently. * - `ref_index`: An ongoing referendum whose hash is `proposal_hash`, which will be * cancelled. * * Weight: `O(p)` (though as this is an high-privilege dispatch, we assume it has a * reasonable value). */ blacklist: TxDescriptor>; /** * Remove a proposal. * * The dispatch origin of this call must be `CancelProposalOrigin`. * * - `prop_index`: The index of the proposal to cancel. * * Weight: `O(p)` where `p = PublicProps::::decode_len()` */ cancel_proposal: TxDescriptor>; /** * Set or clear a metadata of a proposal or a referendum. * * Parameters: * - `origin`: Must correspond to the `MetadataOwner`. * - `ExternalOrigin` for an external proposal with the `SuperMajorityApprove` * threshold. * - `ExternalDefaultOrigin` for an external proposal with the `SuperMajorityAgainst` * threshold. * - `ExternalMajorityOrigin` for an external proposal with the `SimpleMajority` * threshold. * - `Signed` by a creator for a public proposal. * - `Signed` to clear a metadata for a finished referendum. * - `Root` to set a metadata for an ongoing referendum. * - `owner`: an identifier of a metadata owner. * - `maybe_hash`: The hash of an on-chain stored preimage. `None` to clear a metadata. */ set_metadata: TxDescriptor>; /** * Allow to force remove a vote for a referendum. * * Same as `remove_other_vote`, except the scope is overriden by forced flag. * The dispatch origin of this call must be `VoteRemovalOrigin`. * * Only allowed if the referendum is finished. * * The dispatch origin of this call must be _Signed_. * * - `target`: The account of the vote to be removed; this account must have voted for * referendum `index`. * - `index`: The index of referendum of the vote to be removed. * * Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on. * Weight is calculated for the maximum number of vote. */ force_remove_vote: TxDescriptor>; }; Proxy: { /** * Dispatch the given `call` from an account that the sender is authorised for through * `add_proxy`. * * The dispatch origin for this call must be _Signed_. * * Parameters: * - `real`: The account that the proxy will make a call on behalf of. * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. * - `call`: The call to be made by the `real` account. */ proxy: TxDescriptor>; /** * Register a proxy account for the sender that is able to make calls on its behalf. * * The dispatch origin for this call must be _Signed_. * * Parameters: * - `proxy`: The account that the `caller` would like to make a proxy. * - `proxy_type`: The permissions allowed for this proxy account. * - `delay`: The announcement period required of the initial proxy. Will generally be * zero. */ add_proxy: TxDescriptor>; /** * Unregister a proxy account for the sender. * * The dispatch origin for this call must be _Signed_. * * Parameters: * - `proxy`: The account that the `caller` would like to remove as a proxy. * - `proxy_type`: The permissions currently enabled for the removed proxy account. */ remove_proxy: TxDescriptor>; /** * Unregister all proxy accounts for the sender. * * The dispatch origin for this call must be _Signed_. * * WARNING: This may be called on accounts created by `pure`, however if done, then * the unreserved fees will be inaccessible. **All access to this account will be lost.** */ remove_proxies: TxDescriptor; /** * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and * initialize it with a proxy of `proxy_type` for `origin` sender. * * Requires a `Signed` origin. * * - `proxy_type`: The type of the proxy that the sender will be registered as over the * new account. This will almost always be the most permissive `ProxyType` possible to * allow for maximum flexibility. * - `index`: A disambiguation index, in case this is called multiple times in the same * transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just * want to use `0`. * - `delay`: The announcement period required of the initial proxy. Will generally be * zero. * * Fails with `Duplicate` if this has already been called in this transaction, from the * same sender, with the same parameters. * * Fails if there are insufficient funds to pay for deposit. */ create_pure: TxDescriptor>; /** * Removes a previously spawned pure proxy. * * WARNING: **All access to this account will be lost.** Any funds held in it will be * inaccessible. * * Requires a `Signed` origin, and the sender account must have been created by a call to * `pure` with corresponding parameters. * * - `spawner`: The account that originally called `pure` to create this account. * - `index`: The disambiguation index originally passed to `pure`. Probably `0`. * - `proxy_type`: The proxy type originally passed to `pure`. * - `height`: The height of the chain when the call to `pure` was processed. * - `ext_index`: The extrinsic index in which the call to `pure` was processed. * * Fails with `NoPermission` in case the caller is not a previously created pure * account whose `pure` call has corresponding parameters. */ kill_pure: TxDescriptor>; /** * Publish the hash of a proxy-call that will be made in the future. * * This must be called some number of blocks before the corresponding `proxy` is attempted * if the delay associated with the proxy relationship is greater than zero. * * No more than `MaxPending` announcements may be made at any one time. * * This will take a deposit of `AnnouncementDepositFactor` as well as * `AnnouncementDepositBase` if there are no other pending announcements. * * The dispatch origin for this call must be _Signed_ and a proxy of `real`. * * Parameters: * - `real`: The account that the proxy will make a call on behalf of. * - `call_hash`: The hash of the call to be made by the `real` account. */ announce: TxDescriptor>; /** * Remove a given announcement. * * May be called by a proxy account to remove a call they previously announced and return * the deposit. * * The dispatch origin for this call must be _Signed_. * * Parameters: * - `real`: The account that the proxy will make a call on behalf of. * - `call_hash`: The hash of the call to be made by the `real` account. */ remove_announcement: TxDescriptor>; /** * Remove the given announcement of a delegate. * * May be called by a target (proxied) account to remove a call that one of their delegates * (`delegate`) has announced they want to execute. The deposit is returned. * * The dispatch origin for this call must be _Signed_. * * Parameters: * - `delegate`: The account that previously announced the call. * - `call_hash`: The hash of the call to be made. */ reject_announcement: TxDescriptor>; /** * Dispatch the given `call` from an account that the sender is authorized for through * `add_proxy`. * * Removes any corresponding announcement(s). * * The dispatch origin for this call must be _Signed_. * * Parameters: * - `real`: The account that the proxy will make a call on behalf of. * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. * - `call`: The call to be made by the `real` account. */ proxy_announced: TxDescriptor>; /** * Poke / Adjust deposits made for proxies and announcements based on current values. * This can be used by accounts to possibly lower their locked amount. * * The dispatch origin for this call must be _Signed_. * * The transaction fee is waived if the deposit amount has changed. * * Emits `DepositPoked` if successful. */ poke_deposit: TxDescriptor; }; Multisig: { /** * Immediately dispatch a multi-signature call using a single approval from the caller. * * The dispatch origin for this call must be _Signed_. * * - `other_signatories`: The accounts (other than the sender) who are part of the * multi-signature, but do not participate in the approval process. * - `call`: The call to be executed. * * Result is equivalent to the dispatched result. * * ## Complexity * O(Z + C) where Z is the length of the call and C its execution weight. */ as_multi_threshold_1: TxDescriptor>; /** * Register approval for a dispatch to be made from a deterministic composite account if * approved by a total of `threshold - 1` of `other_signatories`. * * If there are enough, then dispatch the call. * * Payment: `DepositBase` will be reserved if this is the first approval, plus * `threshold` times `DepositFactor`. It is returned once this dispatch happens or * is cancelled. * * The dispatch origin for this call must be _Signed_. * * - `threshold`: The total number of approvals for this dispatch before it is executed. * - `other_signatories`: The accounts (other than the sender) who can approve this * dispatch. May not be empty. * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is * not the first approval, then it must be `Some`, with the timepoint (block number and * transaction index) of the first approval transaction. * - `call`: The call to be executed. * * NOTE: Unless this is the final approval, you will generally want to use * `approve_as_multi` instead, since it only requires a hash of the call. * * Result is equivalent to the dispatched result if `threshold` is exactly `1`. Otherwise * on success, result is `Ok` and the result from the interior call, if it was executed, * may be found in the deposited `MultisigExecuted` event. * * ## Complexity * - `O(S + Z + Call)`. * - Up to one balance-reserve or unreserve operation. * - One passthrough operation, one insert, both `O(S)` where `S` is the number of * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. * - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len. * - One encode & hash, both of complexity `O(S)`. * - Up to one binary search and insert (`O(logS + S)`). * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. * - One event. * - The weight of the `call`. * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit * taken for its lifetime of `DepositBase + threshold * DepositFactor`. */ as_multi: TxDescriptor>; /** * Register approval for a dispatch to be made from a deterministic composite account if * approved by a total of `threshold - 1` of `other_signatories`. * * Payment: `DepositBase` will be reserved if this is the first approval, plus * `threshold` times `DepositFactor`. It is returned once this dispatch happens or * is cancelled. * * The dispatch origin for this call must be _Signed_. * * - `threshold`: The total number of approvals for this dispatch before it is executed. * - `other_signatories`: The accounts (other than the sender) who can approve this * dispatch. May not be empty. * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is * not the first approval, then it must be `Some`, with the timepoint (block number and * transaction index) of the first approval transaction. * - `call_hash`: The hash of the call to be executed. * * NOTE: If this is the final approval, you will want to use `as_multi` instead. * * ## Complexity * - `O(S)`. * - Up to one balance-reserve or unreserve operation. * - One passthrough operation, one insert, both `O(S)` where `S` is the number of * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. * - One encode & hash, both of complexity `O(S)`. * - Up to one binary search and insert (`O(logS + S)`). * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. * - One event. * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit * taken for its lifetime of `DepositBase + threshold * DepositFactor`. */ approve_as_multi: TxDescriptor>; /** * Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously * for this operation will be unreserved on success. * * The dispatch origin for this call must be _Signed_. * * - `threshold`: The total number of approvals for this dispatch before it is executed. * - `other_signatories`: The accounts (other than the sender) who can approve this * dispatch. May not be empty. * - `timepoint`: The timepoint (block number and transaction index) of the first approval * transaction for this dispatch. * - `call_hash`: The hash of the call to be executed. * * ## Complexity * - `O(S)`. * - Up to one balance-reserve or unreserve operation. * - One passthrough operation, one insert, both `O(S)` where `S` is the number of * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. * - One encode & hash, both of complexity `O(S)`. * - One event. * - I/O: 1 read `O(S)`, one remove. * - Storage: removes one item. */ cancel_as_multi: TxDescriptor>; /** * Poke the deposit reserved for an existing multisig operation. * * The dispatch origin for this call must be _Signed_ and must be the original depositor of * the multisig operation. * * The transaction fee is waived if the deposit amount has changed. * * - `threshold`: The total number of approvals needed for this multisig. * - `other_signatories`: The accounts (other than the sender) who are part of the * multisig. * - `call_hash`: The hash of the call this deposit is reserved for. * * Emits `DepositPoked` if successful. */ poke_deposit: TxDescriptor>; }; ConvictionVoting: { /** * Vote in a poll. If `vote.is_aye()`, the vote is to enact the proposal; * otherwise it is a vote to keep the status quo. * * The dispatch origin of this call must be _Signed_. * * - `poll_index`: The index of the poll to vote for. * - `vote`: The vote configuration. * * Weight: `O(R)` where R is the number of polls the voter has voted on. */ vote: TxDescriptor>; /** * Delegate the voting power (with some given conviction) of the sending account for a * particular class of polls. * * The balance delegated is locked for as long as it's delegated, and thereafter for the * time appropriate for the conviction's lock period. * * The dispatch origin of this call must be _Signed_, and the signing account must either: * - be delegating already; or * - have no voting activity (if there is, then it will need to be removed through * `remove_vote`). * * - `to`: The account whose voting the `target` account's voting power will follow. * - `class`: The class of polls to delegate. To delegate multiple classes, multiple calls * to this function are required. * - `conviction`: The conviction that will be attached to the delegated votes. When the * account is undelegated, the funds will be locked for the corresponding period. * - `balance`: The amount of the account's balance to be used in delegating. This must not * be more than the account's current balance. * * Emits `Delegated`. * * Weight: `O(R)` where R is the number of polls the voter delegating to has * voted on. Weight is initially charged as if maximum votes, but is refunded later. */ delegate: TxDescriptor>; /** * Undelegate the voting power of the sending account for a particular class of polls. * * Tokens may be unlocked following once an amount of time consistent with the lock period * of the conviction with which the delegation was issued has passed. * * The dispatch origin of this call must be _Signed_ and the signing account must be * currently delegating. * * - `class`: The class of polls to remove the delegation from. * * Emits `Undelegated`. * * Weight: `O(R)` where R is the number of polls the voter delegating to has * voted on. Weight is initially charged as if maximum votes, but is refunded later. */ undelegate: TxDescriptor>; /** * Remove the lock caused by prior voting/delegating which has expired within a particular * class. * * The dispatch origin of this call must be _Signed_. * * - `class`: The class of polls to unlock. * - `target`: The account to remove the lock on. * * Weight: `O(R)` with R number of vote of target. */ unlock: TxDescriptor>; /** * Remove a vote for a poll. * * If: * - the poll was cancelled, or * - the poll is ongoing, or * - the poll has ended such that * - the vote of the account was in opposition to the result; or * - there was no conviction to the account's vote; or * - the account made a split vote * ...then the vote is removed cleanly and a following call to `unlock` may result in more * funds being available. * * If, however, the poll has ended and: * - it finished corresponding to the vote of the account, and * - the account made a standard vote with conviction, and * - the lock period of the conviction is not over * ...then the lock will be aggregated into the overall account's lock, which may involve * *overlocking* (where the two locks are combined into a single lock that is the maximum * of both the amount locked and the time is it locked for). * * The dispatch origin of this call must be _Signed_, and the signer must have a vote * registered for poll `index`. * * - `index`: The index of poll of the vote to be removed. * - `class`: Optional parameter, if given it indicates the class of the poll. For polls * which have finished or are cancelled, this must be `Some`. * * Weight: `O(R + log R)` where R is the number of polls that `target` has voted on. * Weight is calculated for the maximum number of vote. */ remove_vote: TxDescriptor>; /** * Remove a vote for a poll. * * If the `target` is equal to the signer, then this function is exactly equivalent to * `remove_vote`. If not equal to the signer, then the vote must have expired, * either because the poll was cancelled, because the voter lost the poll or * because the conviction period is over. * * The dispatch origin of this call must be _Signed_. * * - `target`: The account of the vote to be removed; this account must have voted for poll * `index`. * - `index`: The index of poll of the vote to be removed. * - `class`: The class of the poll. * * Weight: `O(R + log R)` where R is the number of polls that `target` has voted on. * Weight is calculated for the maximum number of vote. */ remove_other_vote: TxDescriptor>; /** * Allow to force remove a vote for a referendum. * * The dispatch origin of this call must be `VoteRemovalOrigin`. * * Only allowed if the referendum is finished. * * The dispatch origin of this call must be _Signed_. * * - `target`: The account of the vote to be removed; this account must have voted for * referendum `index`. * - `index`: The index of referendum of the vote to be removed. * * Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on. * Weight is calculated for the maximum number of vote. */ force_remove_vote: TxDescriptor>; }; Dispatcher: { /** */ dispatch_as_treasury: TxDescriptor>; /** */ dispatch_as_aave_manager: TxDescriptor>; /** * Sets the Aave manager account to be used as origin for dispatching calls. * * This doesn't actually changes any ACL in the pool. * * This is intented to be mainly used in testnet environments, where the manager account * can be different. */ note_aave_manager: TxDescriptor>; /** * Dispatch a call with extra gas. * * This allows executing calls with additional weight (gas) limit. * The extra gas is not refunded, even if not used. */ dispatch_with_extra_gas: TxDescriptor>; /** * Execute a single EVM call. * This extrinsic will fail if the EVM call returns any other ExitReason than `ExitSucceed(Returned)` or `ExitSucceed(Stopped)`. * Look the [hydradx_runtime::evm::runner::WrapRunner] implementation for details. * * Parameters: * - `origin`: Signed origin. * - `call`: presumably `pallet_evm::Call::call` as boxed `RuntimeCall`. * * Emits `EvmCallFailed` event when failed. */ dispatch_evm_call: TxDescriptor>; }; Omnipool: { /** * Add new token to omnipool in quantity `amount` at price `initial_price` * * Initial liquidity must be transferred to pool's account for this new token manually prior to calling `add_token`. * * Initial liquidity is pool's account balance of the token. * * Position NFT token is minted for `position_owner`. * * Parameters: * - `asset`: The identifier of the new asset added to the pool. Must be registered in Asset registry * - `initial_price`: Initial price * - `position_owner`: account id for which share are distributed in form on NFT * - `weight_cap`: asset weight cap * * Emits `TokenAdded` event when successful. * */ add_token: TxDescriptor>; /** * Add liquidity of asset `asset` in quantity `amount` to Omnipool * * `add_liquidity` adds specified asset amount to Omnipool and in exchange gives the origin * corresponding shares amount in form of NFT at current price. * * Asset's tradable state must contain ADD_LIQUIDITY flag, otherwise `NotAllowed` error is returned. * * NFT is minted using NTFHandler which implements non-fungibles traits from frame_support. * * Asset weight cap must be respected, otherwise `AssetWeightExceeded` error is returned. * Asset weight is ratio between new HubAsset reserve and total reserve of Hub asset in Omnipool. * * Add liquidity fails if price difference between spot price and oracle price is higher than allowed by `PriceBarrier`. * * Parameters: * - `asset`: The identifier of the new asset added to the pool. Must be already in the pool * - `amount`: Amount of asset added to omnipool * * Emits `LiquidityAdded` event when successful. * */ add_liquidity: TxDescriptor>; /** * Add liquidity of asset `asset` in quantity `amount` to Omnipool. * * Limit protection is applied. * * `add_liquidity` adds specified asset amount to Omnipool and in exchange gives the origin * corresponding shares amount in form of NFT at current price. * * Asset's tradable state must contain ADD_LIQUIDITY flag, otherwise `NotAllowed` error is returned. * * NFT is minted using NTFHandler which implements non-fungibles traits from frame_support. * * Asset weight cap must be respected, otherwise `AssetWeightExceeded` error is returned. * Asset weight is ratio between new HubAsset reserve and total reserve of Hub asset in Omnipool. * * Add liquidity fails if price difference between spot price and oracle price is higher than allowed by `PriceBarrier`. * * Parameters: * - `asset`: The identifier of the new asset added to the pool. Must be already in the pool * - `amount`: Amount of asset added to omnipool * - `min_shares_limit`: The min amount of delta share asset the user should receive in the position * * Emits `LiquidityAdded` event when successful. * */ add_liquidity_with_limit: TxDescriptor>; /** * Remove liquidity of asset `asset` in quantity `amount` from Omnipool * * `remove_liquidity` removes specified shares amount from given PositionId (NFT instance). * * Asset's tradable state must contain REMOVE_LIQUIDITY flag, otherwise `NotAllowed` error is returned. * * if all shares from given position are removed, position is destroyed and NFT is burned. * * Remove liquidity fails if price difference between spot price and oracle price is higher than allowed by `PriceBarrier`. * * Dynamic withdrawal fee is applied if withdrawal is not safe. It is calculated using spot price and external price oracle. * Withdrawal is considered safe when trading is disabled. * * Parameters: * - `position_id`: The identifier of position which liquidity is removed from. * - `amount`: Amount of shares removed from omnipool * * Emits `LiquidityRemoved` event when successful. * */ remove_liquidity: TxDescriptor>; /** * Remove liquidity of asset `asset` in quantity `amount` from Omnipool * * Limit protection is applied. * * `remove_liquidity` removes specified shares amount from given PositionId (NFT instance). * * Asset's tradable state must contain REMOVE_LIQUIDITY flag, otherwise `NotAllowed` error is returned. * * if all shares from given position are removed, position is destroyed and NFT is burned. * * Remove liquidity fails if price difference between spot price and oracle price is higher than allowed by `PriceBarrier`. * * Dynamic withdrawal fee is applied if withdrawal is not safe. It is calculated using spot price and external price oracle. * Withdrawal is considered safe when trading is disabled. * * Parameters: * - `position_id`: The identifier of position which liquidity is removed from. * - `amount`: Amount of shares removed from omnipool * - `min_limit`: The min amount of asset to be removed for the user * * Emits `LiquidityRemoved` event when successful. * */ remove_liquidity_with_limit: TxDescriptor>; /** * Remove all liquidity from position * * Limit protection is applied. * * `remove_all_liquidity` removes all shares amount from given PositionId (NFT instance). * * Asset's tradable state must contain REMOVE_LIQUIDITY flag, otherwise `NotAllowed` error is returned. * * if all shares from given position are removed, position is destroyed and NFT is burned. * * Remove all liquidity fails if price difference between spot price and oracle price is higher than allowed by `PriceBarrier`. * * Dynamic withdrawal fee is applied if withdrawal is not safe. It is calculated using spot price and external price oracle. * Withdrawal is considered safe when trading is disabled. * * Parameters: * - `position_id`: The identifier of position which liquidity is entirely removed from. * * Emits `LiquidityRemoved` event when successful. * */ remove_all_liquidity: TxDescriptor>; /** * Sacrifice LP position in favor of pool. * * A position is destroyed and liquidity owned by LP becomes pool owned liquidity. * * Only owner of position can perform this action. * * Emits `PositionDestroyed`. */ sacrifice_position: TxDescriptor>; /** * Execute a swap of `asset_in` for `asset_out`. * * Price is determined by the Omnipool. * * Hub asset is traded separately. * * Asset's tradable states must contain SELL flag for asset_in and BUY flag for asset_out, otherwise `NotAllowed` error is returned. * * Parameters: * - `asset_in`: ID of asset sold to the pool * - `asset_out`: ID of asset bought from the pool * - `amount`: Amount of asset sold * - `min_buy_amount`: Minimum amount required to receive * * Emits `SellExecuted` event when successful. Deprecated. * Emits `pallet_broadcast::Swapped` event when successful. * */ sell: TxDescriptor>; /** * Execute a swap of `asset_out` for `asset_in`. * * Price is determined by the Omnipool. * * Hub asset is traded separately. * * Asset's tradable states must contain SELL flag for asset_in and BUY flag for asset_out, otherwise `NotAllowed` error is returned. * * Parameters: * - `asset_in`: ID of asset sold to the pool * - `asset_out`: ID of asset bought from the pool * - `amount`: Amount of asset sold * - `max_sell_amount`: Maximum amount to be sold. * * Emits `BuyExecuted` event when successful. Deprecated. * Emits `pallet_broadcast::Swapped` event when successful. * */ buy: TxDescriptor>; /** * Update asset's tradable state. * * Parameters: * - `asset_id`: asset id * - `state`: new state * * Emits `TradableStateUpdated` event when successful. * */ set_asset_tradable_state: TxDescriptor>; /** * Refund given amount of asset to a recipient. * * A refund is needed when a token is refused to be added to Omnipool, and initial liquidity of the asset has been already transferred to pool's account. * * Transfer can be executed only if asset is not in Omnipool and pool's balance has sufficient amount. * * Only `AuthorityOrigin` can perform this operation. * * Emits `AssetRefunded` */ refund_refused_asset: TxDescriptor>; /** * Update asset's weight cap * * Parameters: * - `asset_id`: asset id * - `cap`: new weight cap * * Emits `AssetWeightCapUpdated` event when successful. * */ set_asset_weight_cap: TxDescriptor>; /** * Removes protocol liquidity. * * Protocol liquidity is liquidity from sacrificed positions. In order to remove protocol liquidity, * we need the know the price of the position at the time of sacrifice. Hence this specific call. * * Only `AuthorityOrigin` can perform this call. * * Note that sacrifice position will be deprecated in future. There is no longer a need for that. * * It works the same way as remove liquidity call, but position is temporary reconstructed. * */ withdraw_protocol_liquidity: TxDescriptor>; /** * Removes token from Omnipool. * * Asset's tradability must be FROZEN, otherwise `AssetNotFrozen` error is returned. * * Remaining shares must belong to protocol, otherwise `SharesRemaining` error is returned. * * Protocol's liquidity is transferred to the beneficiary account and hub asset amount is burned. * * Only `AuthorityOrigin` can perform this call. * * Emits `TokenRemoved` event when successful. */ remove_token: TxDescriptor>; /** * Set or clear slip fee configuration. * * When set to `Some(config)`, slip fees are enabled with the given parameters. * When set to `None`, slip fees are disabled. * * Can only be called by `UpdateTradabilityOrigin`. * * Emits `SlipFeeSet` event. */ set_slip_fee: TxDescriptor>; }; OmnipoolLiquidityMining: { /** * Create a new liquidity mining program with provided parameters. * * `owner` account has to have at least `total_rewards` balance. These funds will be * transferred from `owner` to farm account. * * The dispatch origin for this call must be `T::CreateOrigin`. * !!!WARN: `T::CreateOrigin` has power over funds of `owner`'s account and it should be * configured to trusted origin e.g Sudo or Governance. * * Parameters: * - `origin`: account allowed to create new liquidity mining program(root, governance). * - `total_rewards`: total rewards planned to distribute. These rewards will be * distributed between all yield farms in the global farm. * - `planned_yielding_periods`: planned number of periods to distribute `total_rewards`. * WARN: THIS IS NOT HARD DEADLINE. Not all rewards have to be distributed in * `planned_yielding_periods`. Rewards are distributed based on the situation in the yield * farms and can be distributed in a longer, though never in a shorter, time frame. * - `blocks_per_period`: number of blocks in a single period. Min. number of blocks per * period is 1. * - `reward_currency`: payoff currency of rewards. * - `owner`: liq. mining farm owner. This account will be able to manage created * liquidity mining program. * - `yield_per_period`: percentage return on `reward_currency` of all farms. * - `min_deposit`: minimum amount of LP shares to be deposited into the liquidity mining by each user. * - `lrna_price_adjustment`: price adjustment between `[LRNA]` and `reward_currency`. * * Emits `GlobalFarmCreated` when successful. * */ create_global_farm: TxDescriptor>; /** * Terminate existing liq. mining program. * * Only farm owner can perform this action. * * WARN: To successfully terminate a global farm, farm have to be empty * (all yield farms in the global farm must be terminated). * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: id of global farm to be terminated. * * Emits `GlobalFarmTerminated` event when successful. * */ terminate_global_farm: TxDescriptor>; /** * Create yield farm for given `asset_id` in the omnipool. * * Only farm owner can perform this action. * * Asset with `asset_id` has to be registered in the omnipool. * At most one `active` yield farm can exist in one global farm for the same `asset_id`. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: global farm id to which a yield farm will be added. * - `asset_id`: id of a asset in the omnipool. Yield farm will be created * for this asset and user will be able to lock LP shares into this yield farm immediately. * - `multiplier`: yield farm's multiplier. * - `loyalty_curve`: curve to calculate loyalty multiplier to distribute rewards to users * with time incentive. `None` means no loyalty multiplier. * * Emits `YieldFarmCreated` event when successful. * */ create_yield_farm: TxDescriptor>; /** * Update yield farm's multiplier. * * Only farm owner can perform this action. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: global farm id in which yield farm will be updated. * - `asset_id`: id of the asset identifying yield farm in the global farm. * - `multiplier`: new yield farm's multiplier. * * Emits `YieldFarmUpdated` event when successful. * */ update_yield_farm: TxDescriptor>; /** * Stop liquidity miming for specific yield farm. * * This function claims rewards from `GlobalFarm` last time and stop yield farm * incentivization from a `GlobalFarm`. Users will be able to only withdraw * shares(with claiming) after calling this function. * `deposit_shares()` is not allowed on stopped yield farm. * * Only farm owner can perform this action. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: farm id in which yield farm will be canceled. * - `asset_id`: id of the asset identifying yield farm in the global farm. * * Emits `YieldFarmStopped` event when successful. * */ stop_yield_farm: TxDescriptor>; /** * Resume incentivization of the asset represented by yield farm. * * This function resume incentivization of the asset from the `GlobalFarm` and * restore full functionality or the yield farm. Users will be able to deposit, * claim and withdraw again. * * WARN: Yield farm(and users) is NOT rewarded for time it was stopped. * * Only farm owner can perform this action. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: global farm id in which yield farm will be resumed. * - `yield_farm_id`: id of the yield farm to be resumed. * - `asset_id`: id of the asset identifying yield farm in the global farm. * - `multiplier`: yield farm multiplier. * * Emits `YieldFarmResumed` event when successful. * */ resume_yield_farm: TxDescriptor>; /** * Terminate yield farm. * * This function marks a yield farm as ready to be removed from storage when it's empty. Users will * be able to only withdraw shares(without claiming rewards from yield farm). Unpaid rewards * will be transferred back to global farm and it will be used to distribute to other yield farms. * * Yield farm must be stopped before it can be terminated. * * Only global farm's owner can perform this action. Yield farm stays in the storage until it's * empty(all farm entries are withdrawn). Last withdrawn from yield farm trigger removing from * the storage. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: global farm id in which yield farm should be terminated. * - `yield_farm_id`: id of yield farm to be terminated. * - `asset_id`: id of the asset identifying yield farm. * * Emits `YieldFarmTerminated` event when successful. * */ terminate_yield_farm: TxDescriptor>; /** * Deposit omnipool position(LP shares) to a liquidity mining. * * This function transfers omnipool position from `origin` to pallet's account and mint NFT for * `origin` account. Minted NFT represents deposit in the liquidity mining. User can * deposit omnipool position as a whole(all the LP shares in the position). * * Parameters: * - `origin`: owner of the omnipool position to deposit into the liquidity mining. * - `global_farm_id`: id of global farm to which user wants to deposit LP shares. * - `yield_farm_id`: id of yield farm to deposit to. * - `position_id`: id of the omnipool position to be deposited into the liquidity mining. * * Emits `SharesDeposited` event when successful. * */ deposit_shares: TxDescriptor>; /** * Redeposit LP shares in the already locked omnipool position. * * This function create yield farm entry for existing deposit. Amount of redeposited LP * shares is same as amount shares which are already deposited in the deposit. * * This function DOESN'T create new deposit(NFT). * * Parameters: * - `origin`: owner of the deposit to redeposit. * - `global_farm_id`: id of the global farm to which user wants to redeposit LP shares. * - `yield_farm_id`: id of the yield farm to redeposit to. * - `deposit_id`: identifier of the deposit to redeposit. * * Emits `SharesRedeposited` event when successful. * */ redeposit_shares: TxDescriptor>; /** * Claim rewards from liquidity mining program for deposit represented by the `deposit_id`. * * This function calculate user rewards from liquidity mining and transfer rewards to `origin` * account. Claiming multiple time the same period is not allowed. * * Parameters: * - `origin`: owner of deposit. * - `deposit_id`: id of the deposit to claim rewards for. * - `yield_farm_id`: id of the yield farm to claim rewards from. * * Emits `RewardClaimed` event when successful. * */ claim_rewards: TxDescriptor>; /** * This function claim rewards and withdraw LP shares from yield farm. Omnipool position * is transferred to origin only if this is last withdraw in the deposit and deposit is * destroyed. This function claim rewards only if yield farm is not terminated and user * didn't already claim rewards in current period. * * Unclaimable rewards represents rewards which user won't be able to claim because of * exiting early and these rewards will be transferred back to global farm for future * redistribution. * * Parameters: * - `origin`: owner of deposit. * - `deposit_id`: id of the deposit to claim rewards for. * - `yield_farm_id`: id of the yield farm to claim rewards from. * * Emits: * * `RewardClaimed` event if claimed rewards is > 0 * * `SharesWithdrawn` event when successful * * `DepositDestroyed` event when this was last withdraw from the deposit and deposit was * destroyed. * */ withdraw_shares: TxDescriptor>; /** * This extrinsic updates global farm's main parameters. * * The dispatch origin for this call must be `T::CreateOrigin`. * !!!WARN: `T::CreateOrigin` has power over funds of `owner`'s account and it should be * configured to trusted origin e.g Sudo or Governance. * * Parameters: * - `origin`: account allowed to create new liquidity mining program(root, governance). * - `global_farm_id`: id of the global farm to update. * - `planned_yielding_periods`: planned number of periods to distribute `total_rewards`. * - `yield_per_period`: percentage return on `reward_currency` of all farms. * - `min_deposit`: minimum amount of LP shares to be deposited into the liquidity mining by each user. * * Emits `GlobalFarmUpdated` event when successful. */ update_global_farm: TxDescriptor>; /** * This function allows user to join multiple farms with a single omnipool position. * * Parameters: * - `origin`: owner of the omnipool position to deposit into the liquidity mining. * - `farm_entries`: list of farms to join. * - `position_id`: id of the omnipool position to be deposited into the liquidity mining. * * Emits `SharesDeposited` event for the first farm entry * Emits `SharesRedeposited` event for each farm entry after the first one */ join_farms: TxDescriptor>; /** * This function allows user to add liquidity then use that shares to join multiple farms. * * Parameters: * - `origin`: owner of the omnipool position to deposit into the liquidity mining. * - `farm_entries`: list of farms to join. * - `asset`: id of the asset to be deposited into the liquidity mining. * - `amount`: amount of the asset to be deposited into the liquidity mining. * - `min_shares_limit`: The min amount of delta share asset the user should receive in the position * * Emits `SharesDeposited` event for the first farm entry * Emits `SharesRedeposited` event for each farm entry after the first one */ add_liquidity_and_join_farms: TxDescriptor>; /** * Exit from all specified yield farms * * This function will attempt to withdraw shares and claim rewards (if available) from all * specified yield farms for a given deposit. * * Parameters: * - `origin`: account owner of deposit(nft). * - `deposit_id`: id of the deposit to claim rewards for. * - `yield_farm_ids`: id(s) of yield farm(s) to exit from. * * Emits: * * `RewardClaimed` for each successful claim * * `SharesWithdrawn` for each successful withdrawal * * `DepositDestroyed` if the deposit is fully withdrawn * */ exit_farms: TxDescriptor>; /** * This function allows user to add liquidity to stableswap pool, * then adding the stable shares as liquidity to omnipool * then use that omnipool shares to join multiple farms. * * If farm entries are not specified (empty vectoo), then the liquidities are still added to the pools * * Parameters: * - `origin`: owner of the omnipool position to deposit into the liquidity mining. * - `stable_pool_id`: id of the stableswap pool to add liquidity to. * - `stable_asset_amounts`: amount of each asset to be deposited into the stableswap pool. * - `farm_entries`: list of farms to join. * - `min_shares_limit`: optional minimum Omnipool shares to receive (slippage protection). * Applies to Omnipool step only. None defaults to no protection. * * Emits `LiquidityAdded` events from both pool * Emits `SharesDeposited` event for the first farm entry * Emits `SharesRedeposited` event for each farm entry after the first one * */ add_liquidity_stableswap_omnipool_and_join_farms: TxDescriptor>; /** * Remove liquidity from stableswap and omnipool, optionally exiting associated yield farms. * * This extrinsic reverses the operation performed by `add_liquidity_stableswap_omnipool_and_join_farms`, * with optional farm exit to match the optional farm join in the add function. * * It performs the following steps in order: * 1. [OPTIONAL] If deposit_id is provided: Exits from ALL yield farms associated with the deposit (claiming rewards) * 2. Removes liquidity from the omnipool to retrieve stableswap shares (protected by omnipool_min_limit) * 3. Removes liquidity from the stableswap pool to retrieve underlying assets (protected by stableswap_min_amounts_out) * * The stabelswap liquidity asset removal strategy is determined by the `min_amounts_out` parameter length: * - If 1 asset is specified: Uses `remove_liquidity_one_asset` (trading fee applies) * - If multiple assets: Uses `remove_liquidity` (proportional, no trading fee) * * Parameters: * - `origin`: Owner of the omnipool position * - `position_id`: The omnipool position NFT ID to remove liquidity from * - `omnipool_min_limit`: The min amount of asset to be removed from omnipool (slippage protection) * - `stableswap_min_amounts_out`: Asset IDs and minimum amounts minimum amounts of each asset to receive from omnipool. * - `deposit_id`: Optional liquidity mining deposit NFT ID. If provided, exits all farms first. * * Emits events: * - If deposit_id provided: `RewardClaimed`, `SharesWithdrawn`, `DepositDestroyed` * - Always: Omnipool's `LiquidityRemoved`, Stableswap's `LiquidityRemoved` * */ remove_liquidity_stableswap_omnipool_and_exit_farms: TxDescriptor>; }; OTC: { /** * Create a new OTC order * * Parameters: * - `asset_in`: Asset which is being bought * - `asset_out`: Asset which is being sold * - `amount_in`: Amount that the order is seeking to buy * - `amount_out`: Amount that the order is selling * - `partially_fillable`: Flag indicating whether users can fill the order partially * * Validations: * - asset_in must be registered * - amount_in must be higher than the existential deposit of asset_in multiplied by * ExistentialDepositMultiplier * - amount_out must be higher than the existential deposit of asset_out multiplied by * ExistentialDepositMultiplier * * Events: * - `Placed` event when successful. */ place_order: TxDescriptor>; /** * Fill an OTC order (partially) * * Parameters: * - `order_id`: ID of the order * - `amount_in`: Amount with which the order is being filled * * Validations: * - order must be partially_fillable * - after the partial_fill, the remaining order.amount_in must be higher than the existential deposit * of asset_in multiplied by ExistentialDepositMultiplier * - after the partial_fill, the remaining order.amount_out must be higher than the existential deposit * of asset_out multiplied by ExistentialDepositMultiplier * * Events: * `PartiallyFilled` event when successful. Deprecated. * `pallet_broadcast::Swapped` event when successful. */ partial_fill_order: TxDescriptor>; /** * Fill an OTC order (completely) * * Parameters: * - `order_id`: ID of the order * * Events: * `Filled` event when successful. Deprecated. * `pallet_broadcast::Swapped` event when successful. */ fill_order: TxDescriptor>; /** * Cancel an open OTC order * * Parameters: * - `order_id`: ID of the order * - `asset`: Asset which is being filled * - `amount`: Amount which is being filled * * Validations: * - caller is order owner * * Emits `Cancelled` event when successful. */ cancel_order: TxDescriptor>; }; Router: { /** * Executes a sell with a series of trades specified in the route. * The price for each trade is determined by the corresponding AMM. * * - `origin`: The executor of the trade * - `asset_in`: The identifier of the asset to sell * - `asset_out`: The identifier of the asset to receive * - `amount_in`: The amount of `asset_in` to sell * - `min_amount_out`: The minimum amount of `asset_out` to receive. * - `route`: Series of [`Trade`] to be executed. A [`Trade`] specifies the asset pair (`asset_in`, `asset_out`) and the AMM (`pool`) in which the trade is executed. * If not specified, than the on-chain route is used. * If no on-chain is present, then omnipool route is used as default * * Emits `RouteExecuted` when successful. */ sell: TxDescriptor>; /** * Executes a buy with a series of trades specified in the route. * The price for each trade is determined by the corresponding AMM. * * - `origin`: The executor of the trade * - `asset_in`: The identifier of the asset to be swapped to buy `asset_out` * - `asset_out`: The identifier of the asset to buy * - `amount_out`: The amount of `asset_out` to buy * - `max_amount_in`: The max amount of `asset_in` to spend on the buy. * - `route`: Series of [`Trade`] to be executed. A [`Trade`] specifies the asset pair (`asset_in`, `asset_out`) and the AMM (`pool`) in which the trade is executed. * If not specified, than the on-chain route is used. * If no on-chain is present, then omnipool route is used as default * * Emits `RouteExecuted` when successful. */ buy: TxDescriptor>; /** * Sets the on-chain route for a given asset pair. * * The new route is validated by being executed in a dry-run mode * * If there is no route explicitly set for an asset pair, then we use the omnipool route as default. * * When a new route is set, we compare it to the existing (or default) route. * The comparison happens by calculating sell amount_outs for the routes, but also for the inversed routes. * * The route is stored in an ordered manner, based on the oder of the ids in the asset pair. * * If the route is set successfully, then the fee is payed back. * * - `origin`: The origin of the route setter * - `asset_pair`: The identifier of the asset-pair for which the route is set * - `new_route`: Series of [`Trade`] to be executed. A [`Trade`] specifies the asset pair (`asset_in`, `asset_out`) and the AMM (`pool`) in which the trade is executed. * * Emits `RouteUpdated` when successful. * * Fails with `RouteUpdateIsNotSuccessful` error when failed to set the route * */ set_route: TxDescriptor>; /** * Force inserts the on-chain route for a given asset pair, so there is no any validation for the route * * Can only be called by T::ForceInsertOrigin * * The route is stored in an ordered manner, based on the oder of the ids in the asset pair. * * If the route is set successfully, then the fee is payed back. * * - `origin`: The origin of the route setter * - `asset_pair`: The identifier of the asset-pair for which the route is set * - `new_route`: Series of [`Trade`] to be executed. A [`Trade`] specifies the asset pair (`asset_in`, `asset_out`) and the AMM (`pool`) in which the trade is executed. * * Emits `RouteUpdated` when successful. * */ force_insert_route: TxDescriptor>; /** * Executes a sell with a series of trades specified in the route. * It sells all reducible user balance of `asset_in` * The price for each trade is determined by the corresponding AMM. * * - `origin`: The executor of the trade * - `asset_in`: The identifier of the asset to sell * - `asset_out`: The identifier of the asset to receive * - `min_amount_out`: The minimum amount of `asset_out` to receive. * - `route`: Series of [`Trade`] to be executed. A [`Trade`] specifies the asset pair (`asset_in`, `asset_out`) and the AMM (`pool`) in which the trade is executed. * If not specified, than the on-chain route is used. * If no on-chain is present, then omnipool route is used as default * * Emits `RouteExecuted` when successful. * */ sell_all: TxDescriptor>; }; Staking: { /** * Staking pallet initialization. This call will reserved `pot`'s balance to prevent * account dusting and start collecting fees from trades as rewards. * * `pot`’s account has to have a balance which will be reserved to prevent account dusting. * * Emits `StakingInitialized` event when successful. * */ initialize_staking: TxDescriptor; /** * Stake `amount` into a new staking position. * * `stake` locks specified `amount` into staking and creates new NFT representing staking * position. * Users can stake `NativeAssetId` balance which is not vested or already staked. * * Staking pallet must be initialized otherwise extrinsic will fail with error. * * Parameters: * - `amount`: Amount of native asset to be staked. `amount` can't be vested or already * staked * * Emits `PositionCreated` event when successful. * */ stake: TxDescriptor>; /** * Extrinsic to increase staked amount of existing staking position by specified `amount`. * * `increase_stake` increases staked amount of position specified by `postion_id` by the * `amount` specified by the user. * Staking position must exist and `origin` has to be the owner of the position. * Users can stake tokens which are not vested or already staked. * Position's params e.g points are updated to offset stake increase and rewards * accumulated until this point are paid and locked to the user. * * Parameters: * - `position_id`: The identifier of the position which stake will be increased. * - `amount`: Amount of native asset to be added to staked amount. `amount` can't be vested or * already staked * * Emits `StakeAdded` event when successful. * */ increase_stake: TxDescriptor>; /** * Claim rewards accumulated for specific staking position. * * Function calculates amount of rewards to pay for specified staking position based on * the amount of points position accumulated. Function also unlocks all the rewards locked * from `increase_stake` based on the amount of the points. * * This action is penalized by removing all the points and returning allocated unpaid rewards * for redistribution. * * Parameters: * - `position_id`: The identifier of the position to claim rewards for. * * Emits `RewardsClaimed` event when successful. * */ claim: TxDescriptor>; /** * Function pays rewards, unlocks all the staked assets and destroys staking position * specified by `position_id`. * * Function calculates and pays latest rewards, unlocks all the locked rewards and staked * tokens for staking position and burns NFT representing staking position. * Unpaid allocated rewards are returned to the Staking for redistribution. * * Parameters: * - `position_id`: The identifier of the position to be destroyed. * * Emits `RewardsClaimed` and `Unstaked` events when successful. * */ unstake: TxDescriptor>; }; Stableswap: { /** * Create a stable pool with given list of assets. * * All assets must be correctly registered in `T::AssetRegistry`. * Note that this does not seed the pool with liquidity. Use `add_assets_liquidity` to provide * initial liquidity. * * Parameters: * - `origin`: Must be T::AuthorityOrigin * - `share_asset`: Preregistered share asset identifier * - `assets`: List of Asset ids * - `amplification`: Pool amplification * - `fee`: fee to be applied on trade and liquidity operations * * Emits `PoolCreated` event if successful. */ create_pool: TxDescriptor>; /** * Update pool's fee. * * if pool does not exist, `PoolNotFound` is returned. * * Parameters: * - `origin`: Must be T::AuthorityOrigin * - `pool_id`: pool to update * - `fee`: new pool fee * * Emits `FeeUpdated` event if successful. */ update_pool_fee: TxDescriptor>; /** * Update pool's amplification. * * Parameters: * - `origin`: Must be T::AuthorityOrigin * - `pool_id`: pool to update * - `final_amplification`: new desired pool amplification * - `start_block`: block number when the amplification starts to move towards final_amplication * - `end_block`: block number when the amplification reaches final_amplification * * Emits `AmplificationUpdated` event if successful. */ update_amplification: TxDescriptor>; /** * Add liquidity to selected pool given exact amount of shares to receive. * * Similar to `add_liquidity` but LP specifies exact amount of shares to receive. * * This functionality is used mainly by on-chain routing when a swap between Omnipool asset and stable asset is performed. * * Parameters: * - `origin`: liquidity provider * - `pool_id`: Pool Id * - `shares`: amount of shares to receive * - `asset_id`: asset id of an asset to provide as liquidity * - `max_asset_amount`: slippage limit. Max amount of asset. * * Emits `LiquidityAdded` event when successful. * Emits `pallet_broadcast::Swapped` event when successful. */ add_liquidity_shares: TxDescriptor>; /** * Remove liquidity from selected pool. * * Withdraws liquidity of selected asset from a pool. * * Share amount is burned and LP receives corresponding amount of chosen asset. * * Withdraw fee is applied to the asset amount. * * Parameters: * - `origin`: liquidity provider * - `pool_id`: Pool Id * - `asset_id`: id of asset to receive * - 'share_amount': amount of shares to withdraw * - 'min_amount_out': minimum amount to receive * * Emits `LiquidityRemoved` event when successful. * Emits `pallet_broadcast::Swapped` event when successful. */ remove_liquidity_one_asset: TxDescriptor>; /** * Remove liquidity from selected pool by specifying exact amount of asset to receive. * * Similar to `remove_liquidity_one_asset` but LP specifies exact amount of asset to receive instead of share amount. * * Parameters: * - `origin`: liquidity provider * - `pool_id`: Pool Id * - `asset_id`: id of asset to receive * - 'amount': amount of asset to receive * - 'max_share_amount': Slippage limit. Max amount of shares to burn. * * Emits `LiquidityRemoved` event when successful. * Emits `pallet_broadcast::Swapped` event when successful. */ withdraw_asset_amount: TxDescriptor>; /** * Execute a swap of `asset_in` for `asset_out`. * * Parameters: * - `origin`: origin of the caller * - `pool_id`: Id of a pool * - `asset_in`: ID of asset sold to the pool * - `asset_out`: ID of asset bought from the pool * - `amount_in`: Amount of asset to be sold to the pool * - `min_buy_amount`: Minimum amount required to receive * * Emits `SellExecuted` event when successful. Deprecated. * Emits `pallet_broadcast::Swapped` event when successful. * */ sell: TxDescriptor>; /** * Execute a swap of `asset_out` for `asset_in`. * * Parameters: * - `origin`: * - `pool_id`: Id of a pool * - `asset_out`: ID of asset bought from the pool * - `asset_in`: ID of asset sold to the pool * - `amount_out`: Amount of asset to receive from the pool * - `max_sell_amount`: Maximum amount allowed to be sold * * Emits `BuyExecuted` event when successful. Deprecated. * Emits `pallet_broadcast::Swapped` event when successful. * */ buy: TxDescriptor>; /** * Update the tradable state of a specific asset in a pool. * * This function allows updating the tradability state of an asset within a pool. The tradability state determines whether the asset can be used for specific operations such as adding liquidity, removing liquidity, buying, or selling. * * Parameters: * - `origin`: Must be `T::UpdateTradabilityOrigin`. * - `pool_id`: The ID of the pool containing the asset. * - `asset_id`: The ID of the asset whose tradability state is to be updated. * - `state`: The new tradability state of the asset. * * Emits `TradableStateUpdated` event when successful. * * # Errors * - `PoolNotFound`: If the specified pool does not exist. * - `AssetNotInPool`: If the specified asset is not part of the pool. * */ set_asset_tradable_state: TxDescriptor>; /** * Remove liquidity from a selected pool uniformly. * * This function allows a liquidity provider to withdraw liquidity from a pool. * The provider specifies the amount of shares to burn and the minimum amounts of each asset to receive. * * Parameters: * - `origin`: The liquidity provider. * - `pool_id`: The ID of the pool from which to remove liquidity. * - `share_amount`: The amount of shares to burn. * - `min_amounts_out`: A bounded vector specifying the minimum amounts of each asset to receive. * * Emits `LiquidityRemoved` event when successful. * Emits `pallet_broadcast::Swapped` event when successful. * * # Errors * - `InvalidAssetAmount`: If the `share_amount` is zero. * - `InsufficientShares`: If the provider does not have enough shares. * - `PoolNotFound`: If the specified pool does not exist. * - `UnknownDecimals`: If the asset decimals cannot be retrieved. * - `IncorrectAssets`: If the provided `min_amounts_out` does not match the pool assets. * - `NotAllowed`: If the asset is not allowed for the operation. * - `SlippageLimit`: If the amount received is less than the specified minimum amount. * - `InsufficientLiquidityRemaining`: If the remaining liquidity in the pool is below the minimum required. * * # Invariants * - Ensures that the pool's reserves are updated correctly after liquidity removal. * - Ensures that the pool's invariant is maintained. */ remove_liquidity: TxDescriptor>; /** * Create a stable pool with a given list of assets and pegs. * * This function allows the creation of a new stable pool with specified assets, amplification, fee, and peg sources. The pool is identified by a share asset. * * Peg target price is determined by retrieving the target peg from the oracle - it is the price of the asset from the peg sourcedenominated in the other pool assets. * * Parameters: * - `origin`: Must be `T::AuthorityOrigin`. * - `share_asset`: Preregistered share asset identifier. * - `assets`: List of asset IDs to be included in the pool. * - `amplification`: Pool amplification parameter. * - `fee`: Fee to be applied on trade and liquidity operations. * - `peg_source`: Bounded vector specifying the source of the peg for each asset. * - `max_peg_update`: Maximum allowed peg update per block. * * Emits `PoolCreated` event if successful. * Emits `AmplificationChanging` event if successful. * * # Errors * - `IncorrectAssets`: If the assets are the same or less than 2 assets are provided. * - `MaxAssetsExceeded`: If the maximum number of assets is exceeded. * - `PoolExists`: If a pool with the given assets already exists. * - `ShareAssetInPoolAssets`: If the share asset is among the pool assets. * - `AssetNotRegistered`: If one or more assets are not registered in the AssetRegistry. * - `InvalidAmplification`: If the amplification parameter is invalid. * - `IncorrectInitialPegs`: If the initial pegs are incorrect. * - `MissingTargetPegOracle`: If the target peg oracle entry is missing. * - `IncorrectAssetDecimals`: If the assets have different decimals. * */ create_pool_with_pegs: TxDescriptor>; /** * Add liquidity to selected pool. * * First call of `add_assets_liquidity` must provide "initial liquidity" of all assets. * * If there is liquidity already in the pool, LP can provide liquidity of any number of pool assets. * * LP must have sufficient amount of each asset. * * Origin is given corresponding amount of shares. * * Parameters: * - `origin`: liquidity provider * - `pool_id`: Pool Id * - `assets`: asset id and liquidity amount provided * - `min_shares`: minimum amount of shares to receive * * Emits `LiquidityAdded` event when successful. * Emits `pallet_broadcast::Swapped` event when successful. */ add_assets_liquidity: TxDescriptor>; /** * Update the peg source for a specific asset in a pool. * * This function allows updating the peg source for an asset within a pool. * The pool must exist and have pegs configured. The asset must be part of the pool. * The current price is always preserved when updating the peg source. * * Parameters: * - `origin`: Must be `T::AuthorityOrigin`. * - `pool_id`: The ID of the pool containing the asset. * - `asset_id`: The ID of the asset whose peg source is to be updated. * - `peg_source`: The new peg source for the asset. * * Emits `PoolPegSourceUpdated` event when successful. * * # Errors * - `PoolNotFound`: If the specified pool does not exist. * - `NoPegSource`: If the pool does not have pegs configured. * - `AssetNotInPool`: If the specified asset is not part of the pool. * */ update_asset_peg_source: TxDescriptor>; /** * Update the maximum peg update percentage for a pool. * * This function allows updating the maximum percentage by which peg values * can change in a pool with pegs configured. * * Parameters: * - `origin`: Must be `T::AuthorityOrigin`. * - `pool_id`: The ID of the pool to update. * - `max_peg_update`: The new maximum peg update percentage. * * Emits `PoolMaxPegUpdateUpdated` event when successful. * * # Errors * - `PoolNotFound`: If the specified pool does not exist. * - `NoPegSource`: If the pool does not have pegs configured. * */ update_pool_max_peg_update: TxDescriptor>; }; XYK: { /** * Create new pool for given asset pair. * * Registers new pool for given asset pair (`asset a` and `asset b`) in asset registry. * Asset registry creates new id or returns previously created one if such pool existed before. * * Pool is created with initial liquidity provided by `origin`. * Shares are issued with specified initial price and represents proportion of asset in the pool. * * Emits `PoolCreated` event when successful. */ create_pool: TxDescriptor>; /** * Add liquidity to previously created asset pair pool. * * Shares are issued with current price. * * Emits `LiquidityAdded` event when successful. */ add_liquidity: TxDescriptor>; /** */ add_liquidity_with_limits: TxDescriptor>; /** * Remove liquidity from specific liquidity pool in the form of burning shares. * * If liquidity in the pool reaches 0, it is destroyed. * * Emits 'LiquidityRemoved' when successful. * Emits 'PoolDestroyed' when pool is destroyed. */ remove_liquidity: TxDescriptor>; /** */ remove_liquidity_with_limits: TxDescriptor>; /** * Trade asset in for asset out. * * Executes a swap of `asset_in` for `asset_out`. Price is determined by the liquidity pool. * * `max_limit` - minimum amount of `asset_out` / amount of asset_out to be obtained from the pool in exchange for `asset_in`. * * Emits `SellExecuted` when successful. Deprecated. * Emits `pallet_broadcast::Swapped` when successful. */ sell: TxDescriptor>; /** * Trade asset in for asset out. * * Executes a swap of `asset_in` for `asset_out`. Price is determined by the liquidity pool. * * `max_limit` - maximum amount of `asset_in` to be sold in exchange for `asset_out`. * Emits `BuyExecuted` when successful. Deprecated. * Emits `pallet_broadcast::Swapped` when successful. */ buy: TxDescriptor>; }; Referrals: { /** * Register new referral code. * * `origin` pays the registration fee. * `code` is assigned to the given `account`. * * Length of the `code` must be at least `T::MinCodeLength`. * Maximum length is limited to `T::CodeLength`. * `code` must contain only alfa-numeric characters and all characters will be converted to upper case. * * Parameters: * - `code`: Code to register. Must follow the restrictions. * * Emits `CodeRegistered` event when successful. */ register_code: TxDescriptor>; /** * Link a code to an account. * * `Code` must be valid registered code. Otherwise `InvalidCode` is returned. * * Signer account is linked to the referral account of the code. * * Parameters: * - `code`: Code to use to link the signer account to. * * Emits `CodeLinked` event when successful. */ link_code: TxDescriptor>; /** * Convert accrued asset amount to reward currency. * * Parameters: * - `asset_id`: Id of an asset to convert to RewardAsset. * * Emits `Converted` event when successful. */ convert: TxDescriptor>; /** * Claim accumulated rewards * * IF there is any asset in the reward pot, all is converted to RewardCurrency first. * * Reward amount is calculated based on the shares of the signer account. * * if the signer account is referrer account, total accumulated rewards is updated as well as referrer level if reached. * * Emits `Claimed` event when successful. */ claim_rewards: TxDescriptor; /** * Set asset reward percentages * * Parameters: * - `asset_id`: asset id * - `level`: level * - `rewards`: reward fee percentages * * Emits `AssetRewardsUpdated` event when successful. */ set_reward_percentage: TxDescriptor>; }; Tokens: { /** * Transfer some liquid free balance to another account. * * `transfer` will set the `FreeBalance` of the sender and receiver. * It will decrease the total issuance of the system by the * `TransferFee`. 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. * * - `dest`: The recipient of the transfer. * - `currency_id`: currency type. * - `amount`: free balance amount to transfer. */ transfer: TxDescriptor>; /** * Transfer all remaining balance to the given 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 for this call must be `Signed` by the * transactor. * * - `dest`: The recipient of the transfer. * - `currency_id`: currency type. * - `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>; /** * Same as the [`transfer`] call, but with a check that the transfer * will not kill the origin account. * * 99% of the time you want [`transfer`] instead. * * The dispatch origin for this call must be `Signed` by the * transactor. * * - `dest`: The recipient of the transfer. * - `currency_id`: currency type. * - `amount`: free balance amount to transfer. */ transfer_keep_alive: TxDescriptor>; /** * Exactly as `transfer`, except the origin must be root and the source * account may be specified. * * The dispatch origin for this call must be _Root_. * * - `source`: The sender of the transfer. * - `dest`: The recipient of the transfer. * - `currency_id`: currency type. * - `amount`: free balance amount to transfer. */ force_transfer: TxDescriptor>; /** * Set the balances of a given account. * * This will alter `FreeBalance` and `ReservedBalance` in storage. it * will also decrease the total issuance of the system * (`TotalIssuance`). If the new free or reserved balance is below the * existential deposit, it will reap the `AccountInfo`. * * The dispatch origin for this call is `root`. */ set_balance: TxDescriptor>; }; Currencies: { /** * Transfer some balance to another account under `currency_id`. * * The dispatch origin for this call must be `Signed` by the * transactor. */ transfer: TxDescriptor>; /** * Transfer some native currency to another account. * * The dispatch origin for this call must be `Signed` by the * transactor. */ transfer_native_currency: TxDescriptor>; /** * update amount of account `who` under `currency_id`. * * The dispatch origin of this call must be _Root_. */ update_balance: TxDescriptor>; }; EVM: { /** * Withdraw balance from EVM into currency/balances pallet. */ withdraw: TxDescriptor>; /** * Issue an EVM call operation. This is similar to a message call transaction in Ethereum. */ call: TxDescriptor>; /** * Issue an EVM create operation. This is similar to a contract creation transaction in * Ethereum. */ create: TxDescriptor>; /** * Issue an EVM create2 operation. */ create2: TxDescriptor>; }; EVMAccounts: { /** * Binds a Substrate address to EVM address. * After binding, the EVM is able to convert an EVM address to the original Substrate address. * Without binding, the EVM converts an EVM address to a truncated Substrate address, which doesn't correspond * to the origin address. * * Binding an address is not necessary for interacting with the EVM. * Increases `sufficients` for the account. * * Parameters: * - `origin`: Substrate account binding an address * * Emits `EvmAccountBound` event when successful. */ bind_evm_address: TxDescriptor; /** * Adds an EVM address to the list of addresses that are allowed to deploy smart contracts. * * Parameters: * - `origin`: Substrate account whitelisting an address. Must be `ControllerOrigin`. * - `address`: EVM address that is whitelisted * * Emits `DeployerAdded` event when successful. */ add_contract_deployer: TxDescriptor>; /** * Removes an EVM address from the list of addresses that are allowed to deploy smart contracts. * * Parameters: * - `origin`: Substrate account removing the EVM address from the whitelist. Must be `ControllerOrigin`. * - `address`: EVM address that is removed from the whitelist * * Emits `DeployerRemoved` event when successful. */ remove_contract_deployer: TxDescriptor>; /** * Removes the account's EVM address from the list of addresses that are allowed to deploy smart contracts. * Based on the best practices, this extrinsic can be called by any whitelisted account to renounce their own permission. * * Parameters: * - `origin`: Substrate account removing their EVM address from the whitelist. * * Emits `DeployerRemoved` event when successful. */ renounce_contract_deployer: TxDescriptor; /** * Adds address of the contract to the list of approved contracts to manage balances. * * Effectively giving it allowance to for any balances and tokens. * * Parameters: * - `origin`: Must be `ControllerOrigin`. * - `address`: Contract address that will be approved * * Emits `ContractApproved` event when successful. */ approve_contract: TxDescriptor>; /** * Removes address of the contract from the list of approved contracts to manage balances. * * Parameters: * - `origin`: Must be `ControllerOrigin`. * - `address`: Contract address that will be disapproved * * Emits `ContractDisapproved` event when successful. */ disapprove_contract: TxDescriptor>; /** * Proves ownership of an account and binds it to the EVM address. * This is useful for accounts that want to submit some substrate transaction, but only * received some ERC20 balance and `System` pallet doesn't register them as a substrate account. * * Parameters: * - `origin`: Unsigned origin. * - `account`: Account proving ownership of the address. * - `asset_id`: Asset ID to be set as fee currency for the account. * - `signature`: Signed message by the account that proves ownership of the account. * * Emits `AccountClaimed` event when successful. */ claim_account: TxDescriptor>; }; XYKLiquidityMining: { /** * Create new liquidity mining program with provided parameters. * * `owner` account has to have at least `total_rewards` balance. This fund will be * transferred from `owner` to farm account. * In case of `reward_currency` is insufficient asset, farm's `owner` has to pay existential * deposit for global farm account and for liquidity mining `pot` account. * * The dispatch origin for this call must be `T::CreateOrigin`. * !!!WARN: `T::CreateOrigin` has power over funds of `owner`'s account and it should be * configured to trusted origin e.g Sudo or Governance. * * Parameters: * - `origin`: global farm's owner. * - `total_rewards`: total rewards planned to distribute. This rewards will be * distributed between all yield farms in the global farm. * - `planned_yielding_periods`: planned number of periods to distribute `total_rewards`. * WARN: THIS IS NOT HARD DEADLINE. Not all rewards have to be distributed in * `planned_yielding_periods`. Rewards are distributed based on the situation in the yield * farms and can be distributed in a longer time frame but never in the shorter time frame. * - `blocks_per_period`: number of blocks in a single period. Min. number of blocks per * period is 1. * - `incentivized_asset`: asset to be incentivized in XYK pools. All yield farms added into * liq. mining program have to have `incentivized_asset` in their pair. * - `reward_currency`: payoff currency of rewards. * - `owner`: liq. mining program owner. * - `yield_per_period`: percentage return on `reward_currency` of all farms p.a. * - `min_deposit`: minimum amount which can be deposited to the farm * - `price_adjustment`: * Emits `GlobalFarmCreated` event when successful. */ create_global_farm: TxDescriptor>; /** * Update global farm's prices adjustment. * * Only farm's owner can perform this action. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: id of the global farm to update * - `price_adjustment`: new value for price adjustment * * Emits `GlobalFarmUpdated` event when successful. */ update_global_farm: TxDescriptor>; /** * Terminate existing liq. mining program. * * Only farm owner can perform this action. * * WARN: To successfully terminate a farm, farm have to be empty(all yield farms in he global farm must be terminated). * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: id of global farm to be terminated. * * Emits `GlobalFarmTerminated` event when successful. */ terminate_global_farm: TxDescriptor>; /** * Add yield farm for given `asset_pair` XYK pool. * * Only farm owner can perform this action. * * Only XYKs with `asset_pair` with `incentivized_asset` can be added into the farm. XYK * pool for `asset_pair` has to exist to successfully create yield farm. * Yield farm for same `asset_pair` can exist only once in the global farm. * * Parameters: * - `origin`: global farm's owner. * - `farm_id`: global farm id to which a yield farm will be added. * - `asset_pair`: asset pair identifying yield farm. Liq. mining will be allowed for this * `asset_pair` and one of the assets in the pair must be `incentivized_asset`. * - `multiplier`: yield farm multiplier. * - `loyalty_curve`: curve to calculate loyalty multiplier to distribute rewards to users * with time incentive. `None` means no loyalty multiplier. * * Emits `YieldFarmCreated` event when successful. */ create_yield_farm: TxDescriptor>; /** * Update yield farm multiplier. * * Only farm owner can perform this action. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: global farm id in which yield farm will be updated. * - `asset_pair`: asset pair identifying yield farm in global farm. * - `multiplier`: new yield farm multiplier. * * Emits `YieldFarmUpdated` event when successful. */ update_yield_farm: TxDescriptor>; /** * Stop liq. miming for specific yield farm. * * This function claims rewards from `GlobalFarm` last time and stops yield farm * incentivization from a `GlobalFarm`. Users will be able to only withdraw * shares(with claiming) after calling this function. * `deposit_shares()` and `claim_rewards()` are not allowed on canceled yield farm. * * Only farm owner can perform this action. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: farm id in which yield farm will be canceled. * - `asset_pair`: asset pair identifying yield farm in the farm. * * Emits `YieldFarmStopped` event when successful. */ stop_yield_farm: TxDescriptor>; /** * Resume yield farm for stopped yield farm. * * This function resume incentivization from `GlobalFarm` and restore full functionality * for yield farm. Users will be able to deposit, claim and withdraw again. * * WARN: Yield farm is NOT rewarded for time it was stopped. * * Only farm owner can perform this action. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: global farm id in which yield farm will be resumed. * - `yield_farm_id`: id of yield farm to be resumed. * - `asset_pair`: asset pair identifying yield farm in global farm. * - `multiplier`: yield farm multiplier in the farm. * * Emits `YieldFarmResumed` event when successful. */ resume_yield_farm: TxDescriptor>; /** * Remove yield farm * * This function marks a yield farm as ready to be removed from storage when it's empty. Users will * be able to only withdraw shares(without claiming rewards from yield farm). Unpaid rewards * will be transferred back to global farm and will be used to distribute to other yield farms. * * Yield farm must be stopped before calling this function. * * Only global farm's owner can perform this action. Yield farm stays in the storage until it's * empty(all farm entries are withdrawn). Last withdrawn from yield farm trigger removing from * the storage. * * Parameters: * - `origin`: global farm's owner. * - `global_farm_id`: farm id from which yield farm should be terminated. * - `yield_farm_id`: id of yield farm to be terminated. * - `asset_pair`: asset pair identifying yield farm in the global farm. * * Emits `YieldFarmTerminated` event when successful. */ terminate_yield_farm: TxDescriptor>; /** * Deposit LP shares to a liq. mining. * * This function transfers LP shares from `origin` to pallet's account and mint nft for * `origin` account. Minted nft represents deposit in the liq. mining. * * Parameters: * - `origin`: account depositing LP shares. This account has to have at least * `shares_amount` of LP shares. * - `global_farm_id`: id of global farm to which user wants to deposit LP shares. * - `yield_farm_id`: id of yield farm to deposit to. * - `asset_pair`: asset pair identifying LP shares user wants to deposit. * - `shares_amount`: amount of LP shares user wants to deposit. * * Emits `SharesDeposited` event when successful. */ deposit_shares: TxDescriptor>; /** * Join multiple farms with a given share amount * * The share is deposited to the first farm of the specified fams, * and then redeposit the shares to the remaining farms * * Parameters: * - `origin`: account depositing LP shares. This account has to have at least * - `farm_entries`: list of global farm id and yield farm id pairs to join * - `asset_pair`: asset pair identifying LP shares user wants to deposit. * - `shares_amount`: amount of LP shares user wants to deposit. * * Emits `SharesDeposited` event for the first farm entry * Emits `SharesRedeposited` event for each farm entry after the first one */ join_farms: TxDescriptor>; /** * Add liquidity to XYK pool and join multiple farms with a given share amount * * The share is deposited to the first farm of the specified entries, * and then redeposit the shares to the remaining farms * * Parameters: * - `origin`: account depositing LP shares. This account has to have at least * - `asset_a`: asset id of the first asset in the pair * - `asset_b`: asset id of the second asset in the pair * - `amount_a`: amount of the first asset to deposit * - `amount_b_max_limit`: maximum amount of the second asset to deposit * - `farm_entries`: list of global farm id and yield farm id pairs to join * * Emits `SharesDeposited` event for the first farm entry * Emits `SharesRedeposited` event for each farm entry after the first one */ add_liquidity_and_join_farms: TxDescriptor>; /** * Redeposit already locked LP shares to another yield farm. * * This function create yield farm entry for existing deposit. LP shares are not transferred * and amount of LP shares is based on existing deposit. * * This function DOESN'T create new deposit. * * Parameters: * - `origin`: account depositing LP shares. This account have to have at least * - `global_farm_id`: global farm identifier. * - `yield_farm_id`: yield farm identifier redepositing to. * - `asset_pair`: asset pair identifying LP shares user want to deposit. * - `deposit_id`: identifier of the deposit. * * Emits `SharesRedeposited` event when successful. */ redeposit_shares: TxDescriptor>; /** * Claim rewards from liq. mining for deposit represented by `nft_id`. * * This function calculate user rewards from liq. mining and transfer rewards to `origin` * account. Claiming in the same period is allowed only once. * * Parameters: * - `origin`: account owner of deposit(nft). * - `deposit_id`: nft id representing deposit in the yield farm. * - `yield_farm_id`: yield farm identifier to claim rewards from. * * Emits `RewardClaimed` event when successful. */ claim_rewards: TxDescriptor>; /** * Withdraw LP shares from liq. mining with reward claiming if possible. * * List of possible cases of transfers of LP shares and claimed rewards: * * * yield farm is active(yield farm is not stopped) - claim and transfer rewards(if it * wasn't claimed in this period) and transfer LP shares. * * liq. mining is stopped - claim and transfer rewards(if it * wasn't claimed in this period) and transfer LP shares. * * yield farm was terminated - only LP shares will be transferred. * * farm was terminated - only LP shares will be transferred. * * User's unclaimable rewards will be transferred back to global farm's account. * * Parameters: * - `origin`: account owner of deposit(nft). * - `deposit_id`: nft id representing deposit in the yield farm. * - `yield_farm_id`: yield farm identifier to dithdraw shares from. * - `asset_pair`: asset pair identifying yield farm in global farm. * * Emits: * * `RewardClaimed` if claim happen * * `SharesWithdrawn` event when successful */ withdraw_shares: TxDescriptor>; /** * Exit from all specified yield farms * * This function will attempt to withdraw shares and claim rewards (if available) from all * specified yield farms for a given deposit. * * Parameters: * - `origin`: account owner of deposit(nft). * - `deposit_id`: nft id representing deposit in the yield farm. * - `asset_pair`: asset pair identifying yield farm(s) in global farm(s). * - `farm_entries`: id(s) of yield farm(s) to exit from. * * Emits: * * `RewardClaimed` for each successful claim * * `SharesWithdrawn` for each successful withdrawal * * `DepositDestroyed` if the deposit is fully withdrawn * */ exit_farms: TxDescriptor>; }; DCA: { /** * Creates a new DCA (Dollar-Cost Averaging) schedule and plans the next execution * for the specified block. * * If the block is not specified, the execution is planned for the next block. * If the given block is full, the execution will be planned in the subsequent block. * * Once the schedule is created, the specified `total_amount` will be reserved for DCA. * The reservation currency will be the `amount_in` currency of the order. * * Trades are executed as long as there is budget remaining * from the initial `total_amount` allocation, unless `total_amount` is 0, then trades * are executed until schedule is terminated. * * If a trade fails due to slippage limit or price stability errors, it will be retried. * If the number of retries reaches the maximum allowed, * the schedule will be terminated permanently. * In the case of a successful trade, the retry counter is reset. * * Parameters: * - `origin`: schedule owner * - `schedule`: schedule details * - `start_execution_block`: first possible execution block for the schedule * * Emits `Scheduled` and `ExecutionPlanned` event when successful. * */ schedule: TxDescriptor>; /** * Terminates a DCA schedule and remove it completely from the chain. * * This can be called by both schedule owner or the configured `T::TerminateOrigin` * * Parameters: * - `origin`: schedule owner * - `schedule_id`: schedule id * - `next_execution_block`: block number where the schedule is planned. * * Emits `Terminated` event when successful. * */ terminate: TxDescriptor>; /** * Unlocks DCA reserves of provided asset for the caller if they have no active schedules. * * This is a utility function to help users recover their reserved funds in case * a DCA schedule was terminated but left some reserved amounts. * * This can only be called when the user has no active DCA schedules. * * Parameters: * - `origin`: The account to unlock reserves for (must be signed) * - `asset_id`: The asset ID for which reserves should be unlocked. * * Emits `ReserveUnlocked` event when successful. * */ unlock_reserves: 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; }; }; type IEvent = { Proxy: { /** * A pure account has been created by new proxy with given * disambiguation index and proxy type. */ PureCreated: PlainDescriptor>; }; Router: { /** * The route with trades has been successfully executed */ Executed: PlainDescriptor>; }; Stableswap: { /** * A pool was created. */ PoolCreated: PlainDescriptor>; /** * Pool fee has been updated. */ FeeUpdated: PlainDescriptor>; /** * Liquidity of an asset was added to a pool. */ LiquidityAdded: PlainDescriptor>; /** * Liquidity removed. */ LiquidityRemoved: PlainDescriptor>; /** * Sell trade executed. Trade fee paid in asset leaving the pool (already subtracted from amount_out). * Deprecated. Replaced by pallet_broadcast::Swapped */ SellExecuted: PlainDescriptor>; /** * Buy trade executed. Trade fee paid in asset entering the pool (already included in amount_in). * Deprecated. Replaced by pallet_broadcast::Swapped */ BuyExecuted: PlainDescriptor>; /** * Asset's tradable state has been updated. */ TradableStateUpdated: PlainDescriptor>; /** * Amplification of a pool has been scheduled to change. */ AmplificationChanging: PlainDescriptor>; /** * A pool has been destroyed. */ PoolDestroyed: PlainDescriptor>; /** * Pool peg source has been updated. */ PoolPegSourceUpdated: PlainDescriptor>; /** * Pool max peg update has been updated. */ PoolMaxPegUpdateUpdated: PlainDescriptor>; }; EVM: { /** * Ethereum events from contracts. */ Log: 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; }; 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; }; MultiTransactionPayment: { /** * Selected currency is not supported. */ UnsupportedCurrency: PlainDescriptor; /** * Account balance should be non-zero. */ ZeroBalance: PlainDescriptor; /** * Currency is already in the list of accepted currencies. */ AlreadyAccepted: PlainDescriptor; /** * It is not allowed to add Core Asset as accepted currency. Core asset is accepted by design. */ CoreAssetNotAllowed: PlainDescriptor; /** * Fallback price cannot be zero. */ ZeroPrice: PlainDescriptor; /** * Fallback price was not found. */ FallbackPriceNotFound: PlainDescriptor; /** * Math overflow */ Overflow: PlainDescriptor; /** * It is not allowed to change payment currency of an EVM account. */ EvmAccountNotAllowed: PlainDescriptor; /** * EVM permit expired. */ EvmPermitExpired: PlainDescriptor; /** * EVM permit is invalid. */ EvmPermitInvalid: PlainDescriptor; /** * EVM permit call failed. */ EvmPermitCallExecutionError: PlainDescriptor; /** * EVM permit call failed. */ EvmPermitRunnerError: PlainDescriptor; /** * EVM permit must not affect account nonce. */ EvmPermitNonceInvariantViolated: PlainDescriptor; }; Treasury: { /** * No proposal, bounty or spend at that index. */ InvalidIndex: PlainDescriptor; /** * Too many approvals in the queue. */ TooManyApprovals: PlainDescriptor; /** * The spend origin is valid but the amount it is allowed to spend is lower than the * amount to be spent. */ InsufficientPermission: PlainDescriptor; /** * Proposal has not been approved. */ ProposalNotApproved: PlainDescriptor; /** * The balance of the asset kind is not convertible to the balance of the native asset. */ FailedToConvertBalance: PlainDescriptor; /** * The spend has expired and cannot be claimed. */ SpendExpired: PlainDescriptor; /** * The spend is not yet eligible for payout. */ EarlyPayout: PlainDescriptor; /** * The payment has already been attempted. */ AlreadyAttempted: PlainDescriptor; /** * There was some issue with the mechanism of payment. */ PayoutError: PlainDescriptor; /** * The payout was not yet attempted/claimed. */ NotAttempted: PlainDescriptor; /** * The payment has neither failed nor succeeded yet. */ Inconclusive: PlainDescriptor; }; Utility: { /** * Too many calls batched. */ TooManyCalls: PlainDescriptor; }; Preimage: { /** * Preimage is too large to store on-chain. */ TooBig: PlainDescriptor; /** * Preimage has already been noted on-chain. */ AlreadyNoted: PlainDescriptor; /** * The user is not authorized to perform this action. */ NotAuthorized: PlainDescriptor; /** * The preimage cannot be removed since it has not yet been noted. */ NotNoted: PlainDescriptor; /** * A preimage may not be removed when there are outstanding requests. */ Requested: PlainDescriptor; /** * The preimage request cannot be removed since no outstanding requests exist. */ NotRequested: PlainDescriptor; /** * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once. */ TooMany: PlainDescriptor; /** * Too few hashes were requested to be upgraded (i.e. zero). */ TooFew: PlainDescriptor; }; Identity: { /** * Too many subs-accounts. */ TooManySubAccounts: PlainDescriptor; /** * Account isn't found. */ NotFound: PlainDescriptor; /** * Account isn't named. */ NotNamed: PlainDescriptor; /** * Empty index. */ EmptyIndex: PlainDescriptor; /** * Fee is changed. */ FeeChanged: PlainDescriptor; /** * No identity found. */ NoIdentity: PlainDescriptor; /** * Sticky judgement. */ StickyJudgement: PlainDescriptor; /** * Judgement given. */ JudgementGiven: PlainDescriptor; /** * Invalid judgement. */ InvalidJudgement: PlainDescriptor; /** * The index is invalid. */ InvalidIndex: PlainDescriptor; /** * The target is invalid. */ InvalidTarget: PlainDescriptor; /** * Maximum amount of registrars reached. Cannot add any more. */ TooManyRegistrars: PlainDescriptor; /** * Account ID is already named. */ AlreadyClaimed: PlainDescriptor; /** * Sender is not a sub-account. */ NotSub: PlainDescriptor; /** * Sub-account isn't owned by sender. */ NotOwned: PlainDescriptor; /** * The provided judgement was for a different identity. */ JudgementForDifferentIdentity: PlainDescriptor; /** * Error that occurs when there is an issue paying for judgement. */ JudgementPaymentFailed: PlainDescriptor; /** * The provided suffix is too long. */ InvalidSuffix: PlainDescriptor; /** * The sender does not have permission to issue a username. */ NotUsernameAuthority: PlainDescriptor; /** * The authority cannot allocate any more usernames. */ NoAllocation: PlainDescriptor; /** * The signature on a username was not valid. */ InvalidSignature: PlainDescriptor; /** * Setting this username requires a signature, but none was provided. */ RequiresSignature: PlainDescriptor; /** * The username does not meet the requirements. */ InvalidUsername: PlainDescriptor; /** * The username is already taken. */ UsernameTaken: PlainDescriptor; /** * The requested username does not exist. */ NoUsername: PlainDescriptor; /** * The username cannot be forcefully removed because it can still be accepted. */ NotExpired: PlainDescriptor; /** * The username cannot be removed because it's still in the grace period. */ TooEarly: PlainDescriptor; /** * The username cannot be removed because it is not unbinding. */ NotUnbinding: PlainDescriptor; /** * The username cannot be unbound because it is already unbinding. */ AlreadyUnbinding: PlainDescriptor; /** * The action cannot be performed because of insufficient privileges (e.g. authority * trying to unbind a username provided by the system). */ InsufficientPrivileges: PlainDescriptor; }; Democracy: { /** * Value too low */ ValueLow: PlainDescriptor; /** * Proposal does not exist */ ProposalMissing: PlainDescriptor; /** * Cannot cancel the same proposal twice */ AlreadyCanceled: PlainDescriptor; /** * Proposal already made */ DuplicateProposal: PlainDescriptor; /** * Proposal still blacklisted */ ProposalBlacklisted: PlainDescriptor; /** * Next external proposal not simple majority */ NotSimpleMajority: PlainDescriptor; /** * Invalid hash */ InvalidHash: PlainDescriptor; /** * No external proposal */ NoProposal: PlainDescriptor; /** * Identity may not veto a proposal twice */ AlreadyVetoed: PlainDescriptor; /** * Vote given for invalid referendum */ ReferendumInvalid: PlainDescriptor; /** * No proposals waiting */ NoneWaiting: PlainDescriptor; /** * The given account did not vote on the referendum. */ NotVoter: PlainDescriptor; /** * The actor has no permission to conduct the action. */ NoPermission: PlainDescriptor; /** * The account is already delegating. */ AlreadyDelegating: PlainDescriptor; /** * Too high a balance was provided that the account cannot afford. */ InsufficientFunds: PlainDescriptor; /** * The account is not currently delegating. */ NotDelegating: PlainDescriptor; /** * The account currently has votes attached to it and the operation cannot succeed until * these are removed, either through `unvote` or `reap_vote`. */ VotesExist: PlainDescriptor; /** * The instant referendum origin is currently disallowed. */ InstantNotAllowed: PlainDescriptor; /** * Delegation to oneself makes no sense. */ Nonsense: PlainDescriptor; /** * Invalid upper bound. */ WrongUpperBound: PlainDescriptor; /** * Maximum number of votes reached. */ MaxVotesReached: PlainDescriptor; /** * Maximum number of items reached. */ TooMany: PlainDescriptor; /** * Voting period too low */ VotingPeriodLow: PlainDescriptor; /** * The preimage does not exist. */ PreimageNotExist: PlainDescriptor; }; TechnicalCommittee: { /** * Account is not a member */ NotMember: PlainDescriptor; /** * Duplicate proposals not allowed */ DuplicateProposal: PlainDescriptor; /** * Proposal must exist */ ProposalMissing: PlainDescriptor; /** * Mismatched index */ WrongIndex: PlainDescriptor; /** * Duplicate vote ignored */ DuplicateVote: PlainDescriptor; /** * Members are already initialized! */ AlreadyInitialized: PlainDescriptor; /** * The close call was made too early, before the end of the voting. */ TooEarly: PlainDescriptor; /** * There can only be a maximum of `MaxProposals` active proposals. */ TooManyProposals: PlainDescriptor; /** * The given weight bound for the proposal was too low. */ WrongProposalWeight: PlainDescriptor; /** * The given length bound for the proposal was too low. */ WrongProposalLength: PlainDescriptor; /** * Prime account is not a member */ PrimeAccountNotMember: PlainDescriptor; /** * Proposal is still active. */ ProposalActive: PlainDescriptor; }; Proxy: { /** * There are too many proxies registered or too many announcements pending. */ TooMany: PlainDescriptor; /** * Proxy registration not found. */ NotFound: PlainDescriptor; /** * Sender is not a proxy of the account to be proxied. */ NotProxy: PlainDescriptor; /** * A call which is incompatible with the proxy type's filter was attempted. */ Unproxyable: PlainDescriptor; /** * Account is already a proxy. */ Duplicate: PlainDescriptor; /** * Call may not be made by proxy because it may escalate its privileges. */ NoPermission: PlainDescriptor; /** * Announcement, if made at all, was made too recently. */ Unannounced: PlainDescriptor; /** * Cannot add self as proxy. */ NoSelfProxy: PlainDescriptor; }; Multisig: { /** * Threshold must be 2 or greater. */ MinimumThreshold: PlainDescriptor; /** * Call is already approved by this signatory. */ AlreadyApproved: PlainDescriptor; /** * Call doesn't need any (more) approvals. */ NoApprovalsNeeded: PlainDescriptor; /** * There are too few signatories in the list. */ TooFewSignatories: PlainDescriptor; /** * There are too many signatories in the list. */ TooManySignatories: PlainDescriptor; /** * The signatories were provided out of order; they should be ordered. */ SignatoriesOutOfOrder: PlainDescriptor; /** * The sender was contained in the other signatories; it shouldn't be. */ SenderInSignatories: PlainDescriptor; /** * Multisig operation not found in storage. */ NotFound: PlainDescriptor; /** * Only the account that originally created the multisig is able to cancel it or update * its deposits. */ NotOwner: PlainDescriptor; /** * No timepoint was given, yet the multisig operation is already underway. */ NoTimepoint: PlainDescriptor; /** * A different timepoint was given to the multisig operation that is underway. */ WrongTimepoint: PlainDescriptor; /** * A timepoint was given, yet no multisig operation is underway. */ UnexpectedTimepoint: PlainDescriptor; /** * The maximum weight information provided was too low. */ MaxWeightTooLow: PlainDescriptor; /** * The data to be stored is already stored. */ AlreadyStored: PlainDescriptor; }; Uniques: { /** * The signing account has no permission to do the operation. */ NoPermission: PlainDescriptor; /** * The given item ID is unknown. */ UnknownCollection: PlainDescriptor; /** * The item ID has already been used for an item. */ AlreadyExists: PlainDescriptor; /** * The owner turned out to be different to what was expected. */ WrongOwner: PlainDescriptor; /** * Invalid witness data given. */ BadWitness: PlainDescriptor; /** * The item ID is already taken. */ InUse: PlainDescriptor; /** * The item or collection is frozen. */ Frozen: PlainDescriptor; /** * The delegate turned out to be different to what was expected. */ WrongDelegate: PlainDescriptor; /** * There is no delegate approved. */ NoDelegate: PlainDescriptor; /** * No approval exists that would allow the transfer. */ Unapproved: PlainDescriptor; /** * The named owner has not signed ownership of the collection is acceptable. */ Unaccepted: PlainDescriptor; /** * The item is locked. */ Locked: PlainDescriptor; /** * All items have been minted. */ MaxSupplyReached: PlainDescriptor; /** * The max supply has already been set. */ MaxSupplyAlreadySet: PlainDescriptor; /** * The provided max supply is less to the amount of items a collection already has. */ MaxSupplyTooSmall: PlainDescriptor; /** * The given item ID is unknown. */ UnknownItem: PlainDescriptor; /** * Item is not for sale. */ NotForSale: PlainDescriptor; /** * The provided bid is too low. */ BidTooLow: PlainDescriptor; }; StateTrieMigration: { /** * Max signed limits not respected. */ MaxSignedLimits: PlainDescriptor; /** * A key was longer than the configured maximum. * * This means that the migration halted at the current [`Progress`] and * can be resumed with a larger [`crate::Config::MaxKeyLen`] value. * Retrying with the same [`crate::Config::MaxKeyLen`] value will not work. * The value should only be increased to avoid a storage migration for the currently * stored [`crate::Progress::LastKey`]. */ KeyTooLong: PlainDescriptor; /** * submitter does not have enough funds. */ NotEnoughFunds: PlainDescriptor; /** * Bad witness data provided. */ BadWitness: PlainDescriptor; /** * Signed migration is not allowed because the maximum limit is not set yet. */ SignedMigrationNotAllowed: PlainDescriptor; /** * Bad child root provided. */ BadChildRoot: PlainDescriptor; }; ConvictionVoting: { /** * Poll is not ongoing. */ NotOngoing: PlainDescriptor; /** * The given account did not vote on the poll. */ NotVoter: PlainDescriptor; /** * The actor has no permission to conduct the action. */ NoPermission: PlainDescriptor; /** * The actor has no permission to conduct the action right now but will do in the future. */ NoPermissionYet: PlainDescriptor; /** * The account is already delegating. */ AlreadyDelegating: PlainDescriptor; /** * The account currently has votes attached to it and the operation cannot succeed until * these are removed through `remove_vote`. */ AlreadyVoting: PlainDescriptor; /** * Too high a balance was provided that the account cannot afford. */ InsufficientFunds: PlainDescriptor; /** * The account is not currently delegating. */ NotDelegating: PlainDescriptor; /** * Delegation to oneself makes no sense. */ Nonsense: PlainDescriptor; /** * Maximum number of votes reached. */ MaxVotesReached: PlainDescriptor; /** * The class must be supplied since it is not easily determinable from the state. */ ClassNeeded: PlainDescriptor; /** * The class ID supplied is invalid. */ BadClass: PlainDescriptor; }; Referenda: { /** * Referendum is not ongoing. */ NotOngoing: PlainDescriptor; /** * Referendum's decision deposit is already paid. */ HasDeposit: PlainDescriptor; /** * The track identifier given was invalid. */ BadTrack: PlainDescriptor; /** * There are already a full complement of referenda in progress for this track. */ Full: PlainDescriptor; /** * The queue of the track is empty. */ QueueEmpty: PlainDescriptor; /** * The referendum index provided is invalid in this context. */ BadReferendum: PlainDescriptor; /** * There was nothing to do in the advancement. */ NothingToDo: PlainDescriptor; /** * No track exists for the proposal origin. */ NoTrack: PlainDescriptor; /** * Any deposit cannot be refunded until after the decision is over. */ Unfinished: PlainDescriptor; /** * The deposit refunder is not the depositor. */ NoPermission: PlainDescriptor; /** * The deposit cannot be refunded since none was made. */ NoDeposit: PlainDescriptor; /** * The referendum status is invalid for this operation. */ BadStatus: PlainDescriptor; /** * The preimage does not exist. */ PreimageNotExist: PlainDescriptor; /** * The preimage is stored with a different length than the one provided. */ PreimageStoredWithDifferentLength: PlainDescriptor; }; Whitelist: { /** * The preimage of the call hash could not be loaded. */ UnavailablePreImage: PlainDescriptor; /** * The call could not be decoded. */ UndecodableCall: PlainDescriptor; /** * The weight of the decoded call was higher than the witness. */ InvalidCallWeightWitness: PlainDescriptor; /** * The call was not whitelisted. */ CallIsNotWhitelisted: PlainDescriptor; /** * The call was already whitelisted; No-Op. */ CallAlreadyWhitelisted: PlainDescriptor; }; Dispatcher: { /** * The EVM call execution failed. This happens when the EVM returns an exit reason * other than `ExitSucceed(Returned)` or `ExitSucceed(Stopped)`. */ EvmCallFailed: PlainDescriptor; /** * The provided call is not an EVM call. This extrinsic only accepts `pallet_evm::Call::call`. */ NotEvmCall: PlainDescriptor; /** * The EVM call ran out of gas. */ EvmOutOfGas: PlainDescriptor; /** * The EVM call resulted in an arithmetic overflow or underflow. */ EvmArithmeticOverflowOrUnderflow: PlainDescriptor; /** * Aave - supply cap has been exceeded. */ AaveSupplyCapExceeded: PlainDescriptor; /** * Aave - borrow cap has been exceeded. */ AaveBorrowCapExceeded: PlainDescriptor; /** * Aave - health factor is not below the threshold. */ AaveHealthFactorNotBelowThreshold: PlainDescriptor; /** * Aave - health factor is lesser than the liquidation threshold */ AaveHealthFactorLowerThanLiquidationThreshold: PlainDescriptor; /** * Aave - there is not enough collateral to cover a new borrow */ CollateralCannotCoverNewBorrow: PlainDescriptor; }; AssetRegistry: { /** * Asset ID is not available. This only happens when it reaches the MAX value of given id type. */ NoIdAvailable: PlainDescriptor; /** * Invalid asset name or symbol. */ AssetNotFound: PlainDescriptor; /** * Length of name or symbol is less than min. length. */ TooShort: PlainDescriptor; /** * Asset's symbol can't contain whitespace characters . */ InvalidSymbol: PlainDescriptor; /** * Asset ID is not registered in the asset-registry. */ AssetNotRegistered: PlainDescriptor; /** * Asset is already registered. */ AssetAlreadyRegistered: PlainDescriptor; /** * Incorrect number of assets provided to create shared asset. */ InvalidSharedAssetLen: PlainDescriptor; /** * Cannot update asset location. */ CannotUpdateLocation: PlainDescriptor; /** * Selected asset id is out of reserved range. */ NotInReservedRange: PlainDescriptor; /** * Location already registered with different asset. */ LocationAlreadyRegistered: PlainDescriptor; /** * Origin is forbidden to set/update value. */ Forbidden: PlainDescriptor; /** * Balance too low. */ InsufficientBalance: PlainDescriptor; /** * Sufficient assets can't be changed to insufficient. */ ForbiddenSufficiencyChange: PlainDescriptor; /** * Asset is already banned. */ AssetAlreadyBanned: PlainDescriptor; /** * Asset is not banned. */ AssetNotBanned: PlainDescriptor; }; Claims: { /** * Ethereum signature is not valid */ InvalidEthereumSignature: PlainDescriptor; /** * Claim is not valid */ NoClaimOrAlreadyClaimed: PlainDescriptor; /** * Value reached maximum and cannot be incremented further */ BalanceOverflow: PlainDescriptor; }; Omnipool: { /** * Balance too low */ InsufficientBalance: PlainDescriptor; /** * Asset is already in omnipool */ AssetAlreadyAdded: PlainDescriptor; /** * Asset is not in omnipool */ AssetNotFound: PlainDescriptor; /** * Failed to add token to Omnipool due to insufficient initial liquidity. */ MissingBalance: PlainDescriptor; /** * Invalid initial asset price. */ InvalidInitialAssetPrice: PlainDescriptor; /** * Slippage protection - minimum limit has not been reached. */ BuyLimitNotReached: PlainDescriptor; /** * Slippage protection - maximum limit has been exceeded. */ SellLimitExceeded: PlainDescriptor; /** * Position has not been found. */ PositionNotFound: PlainDescriptor; /** * Insufficient shares in position */ InsufficientShares: PlainDescriptor; /** * Asset is not allowed to be traded. */ NotAllowed: PlainDescriptor; /** * Signed account is not owner of position instance. */ Forbidden: PlainDescriptor; /** * Asset weight cap has been exceeded. */ AssetWeightCapExceeded: PlainDescriptor; /** * Asset is not registered in asset registry */ AssetNotRegistered: PlainDescriptor; /** * Provided liquidity is below minimum allowed limit */ InsufficientLiquidity: PlainDescriptor; /** * Traded amount is below minimum allowed limit */ InsufficientTradingAmount: PlainDescriptor; /** * Sell or buy with same asset ids is not allowed. */ SameAssetTradeNotAllowed: PlainDescriptor; /** * Hub asset reserve update after trade resulted in unexpected Decrease. */ HubAssetUpdateError: PlainDescriptor; /** * Amount of shares provided cannot be 0. */ InvalidSharesAmount: PlainDescriptor; /** * Hub asset is only allowed to be sold. */ InvalidHubAssetTradableState: PlainDescriptor; /** * Asset is not allowed to be refunded. */ AssetRefundNotAllowed: PlainDescriptor; /** * Max fraction of asset to buy has been exceeded. */ MaxOutRatioExceeded: PlainDescriptor; /** * Max fraction of asset to sell has been exceeded. */ MaxInRatioExceeded: PlainDescriptor; /** * Max allowed price difference has been exceeded. */ PriceDifferenceTooHigh: PlainDescriptor; /** * Invalid oracle price - division by zero. */ InvalidOraclePrice: PlainDescriptor; /** * Failed to calculate withdrawal fee. */ InvalidWithdrawalFee: PlainDescriptor; /** * More than allowed amount of fee has been transferred. */ FeeOverdraft: PlainDescriptor; /** * Token cannot be removed from Omnipool due to shares still owned by other users. */ SharesRemaining: PlainDescriptor; /** * Token cannot be removed from Omnipool because asset is not frozen. */ AssetNotFrozen: PlainDescriptor; /** * Calculated amount out from sell trade is zero. */ ZeroAmountOut: PlainDescriptor; /** * Existential deposit of asset is not available. */ ExistentialDepositNotAvailable: PlainDescriptor; /** * Slippage protection */ SlippageLimit: PlainDescriptor; /** * Extra protocol fee has not been consumed. */ ProtocolFeeNotConsumed: PlainDescriptor; /** * Slip fee configuration exceeds the allowed maximum (50%). */ MaxSlipFeeTooHigh: PlainDescriptor; }; TransactionPause: { /** * can not pause */ CannotPause: PlainDescriptor; /** * invalid character encoding */ InvalidCharacter: PlainDescriptor; /** * pallet name or function name is too long */ NameTooLong: PlainDescriptor; }; Duster: { /** * Account is excluded from dusting. */ AccountWhitelisted: PlainDescriptor; /** * Account is not present in the non-dustable list. */ AccountNotWhitelisted: PlainDescriptor; /** * The balance is zero. */ ZeroBalance: PlainDescriptor; /** * The balance was not fully dusted, there is some leftover on the account. Normally, it should never happen. */ NonZeroBalance: PlainDescriptor; /** * The balance is sufficient to keep account open. */ BalanceSufficient: PlainDescriptor; /** * Reserve account is not set. */ ReserveAccountNotSet: PlainDescriptor; }; OmnipoolWarehouseLM: { /** * Global farm does not exist. */ GlobalFarmNotFound: PlainDescriptor; /** * Yield farm does not exist. */ YieldFarmNotFound: PlainDescriptor; /** * Multiple claims in the same period is not allowed. */ DoubleClaimInPeriod: PlainDescriptor; /** * Liquidity mining is canceled. */ LiquidityMiningCanceled: PlainDescriptor; /** * Liquidity mining is not canceled. */ LiquidityMiningIsActive: PlainDescriptor; /** * Liquidity mining is in `active` or `terminated` state and action cannot be completed. */ LiquidityMiningIsNotStopped: PlainDescriptor; /** * Account is not allowed to perform action. */ Forbidden: PlainDescriptor; /** * Yield farm multiplier can't be 0. */ InvalidMultiplier: PlainDescriptor; /** * Yield farm with given `amm_pool_id` already exists in global farm. */ YieldFarmAlreadyExists: PlainDescriptor; /** * Loyalty curve's initial reward percentage is not valid. Valid range is: [0, 1). */ InvalidInitialRewardPercentage: PlainDescriptor; /** * One or more yield farms exist in global farm. */ GlobalFarmIsNotEmpty: PlainDescriptor; /** * Farm's `incentivized_asset` is missing in provided asset pair. */ MissingIncentivizedAsset: PlainDescriptor; /** * Reward currency balance is not sufficient. */ InsufficientRewardCurrencyBalance: PlainDescriptor; /** * Blocks per period can't be 0. */ InvalidBlocksPerPeriod: PlainDescriptor; /** * Yield per period can't be 0. */ InvalidYieldPerPeriod: PlainDescriptor; /** * Total rewards is less than `MinTotalFarmRewards`. */ InvalidTotalRewards: PlainDescriptor; /** * Planned yielding periods is less than `MinPlannedYieldingPeriods`. */ InvalidPlannedYieldingPeriods: PlainDescriptor; /** * Maximum number of locks reached for deposit. */ MaxEntriesPerDeposit: PlainDescriptor; /** * Trying to lock LP shares into already locked yield farm. */ DoubleLock: PlainDescriptor; /** * Yield farm entry doesn't exist for given deposit. */ YieldFarmEntryNotFound: PlainDescriptor; /** * Max number of yield farms in global farm was reached. Global farm can't accept new * yield farms until some yield farm is not removed from storage. */ GlobalFarmIsFull: PlainDescriptor; /** * Invalid min. deposit was set for global farm. */ InvalidMinDeposit: PlainDescriptor; /** * Price adjustment multiplier can't be 0. */ InvalidPriceAdjustment: PlainDescriptor; /** * Account creation from id failed. */ ErrorGetAccountId: PlainDescriptor; /** * Value of deposited shares amount in reward currency is bellow min. limit. */ IncorrectValuedShares: PlainDescriptor; /** * `reward_currency` is not registered in asset registry. */ RewardCurrencyNotRegistered: PlainDescriptor; /** * `incentivized_asset` is not registered in asset registry. */ IncentivizedAssetNotRegistered: PlainDescriptor; /** * Provided `amm_pool_id` doesn't match deposit's `amm_pool_id`. */ AmmPoolIdMismatch: PlainDescriptor; /** * Action cannot be completed because unexpected error has occurred. This should be reported * to protocol maintainers. */ InconsistentState: PlainDescriptor>; }; OmnipoolLiquidityMining: { /** * Asset is not in the omnipool. */ AssetNotFound: PlainDescriptor; /** * Signed account is not owner of the deposit. */ Forbidden: PlainDescriptor; /** * Rewards to claim are 0. */ ZeroClaimedRewards: PlainDescriptor; /** * Action cannot be completed because unexpected error has occurred. This should be reported * to protocol maintainers. */ InconsistentState: PlainDescriptor>; /** * Oracle could not be found for requested assets. */ OracleNotAvailable: PlainDescriptor; /** * Oracle providing `price_adjustment` could not be found for requested assets. */ PriceAdjustmentNotAvailable: PlainDescriptor; /** * No farms specified to join */ NoFarmEntriesSpecified: PlainDescriptor; /** * No assets specified in the withdrawal */ NoAssetsSpecified: PlainDescriptor; /** * The provided position_id does not match the deposit's associated position. */ PositionIdMismatch: PlainDescriptor; }; OTC: { /** * Asset does not exist in registry */ AssetNotRegistered: PlainDescriptor; /** * Order cannot be found */ OrderNotFound: PlainDescriptor; /** * Size of order ID exceeds the bound */ OrderIdOutOfBound: PlainDescriptor; /** * Cannot partially fill an order which is not partially fillable */ OrderNotPartiallyFillable: PlainDescriptor; /** * Order amount_in and amount_out must at all times be greater than the existential deposit * for the asset multiplied by the ExistentialDepositMultiplier. * A fill order may not leave behind amounts smaller than this. */ OrderAmountTooSmall: PlainDescriptor; /** * Error with math calculations */ MathError: PlainDescriptor; /** * The caller does not have permission to complete the action */ Forbidden: PlainDescriptor; /** * Reserved amount not sufficient. */ InsufficientReservedAmount: PlainDescriptor; }; CircuitBreaker: { /** * Invalid value for a limit. Limit must be non-zero. */ InvalidLimitValue: PlainDescriptor; /** * Allowed liquidity limit is not stored for asset */ LiquidityLimitNotStoredForAsset: PlainDescriptor; /** * Token trade outflow per block has been reached */ TokenOutflowLimitReached: PlainDescriptor; /** * Token trade influx per block has been reached */ TokenInfluxLimitReached: PlainDescriptor; /** * Maximum pool's liquidity limit per block has been reached */ MaxLiquidityLimitPerBlockReached: PlainDescriptor; /** * Asset is not allowed to have a limit */ NotAllowed: PlainDescriptor; /** * Asset still in lockdown as it reached the allowed deposit limit for the period * Query the `asset_lockdown_state` storage to determine until which block the asset is locked, * so that the deposit can be released afterward. */ AssetInLockdown: PlainDescriptor; /** * Asset is not in a lockdown */ AssetNotInLockdown: PlainDescriptor; /** * Invalid amount to save deposit */ InvalidAmount: PlainDescriptor; /** * Deposit limit would be exceeded for a whitelisted account. * Operation rejected to prevent funds being locked on system accounts. */ DepositLimitExceededForWhitelistedAccount: PlainDescriptor; /** * Global lockdown is active and withdrawals that participate in the global limit are blocked. */ WithdrawLockdownActive: PlainDescriptor; /** * Applying the increment would exceed the configured global limit -> lockdown is triggered and operation fails. */ GlobalWithdrawLimitExceeded: PlainDescriptor; /** * Asset to withdraw cannot be converted to reference currency. */ FailedToConvertAsset: PlainDescriptor; }; Router: { /** * The trading limit has been reached */ TradingLimitReached: PlainDescriptor; /** * The the max number of trades limit is reached */ MaxTradesExceeded: PlainDescriptor; /** * The AMM pool is not supported for executing trades */ PoolNotSupported: PlainDescriptor; /** * The user has not enough balance to execute the trade */ InsufficientBalance: PlainDescriptor; /** * The calculation of route trade amounts failed in the underlying AMM */ RouteCalculationFailed: PlainDescriptor; /** * The route is invalid */ InvalidRoute: PlainDescriptor; /** * The route update was not successful */ RouteUpdateIsNotSuccessful: PlainDescriptor; /** * Route contains assets that has no oracle data */ RouteHasNoOracle: PlainDescriptor; /** * The route execution failed in the underlying AMM */ InvalidRouteExecution: PlainDescriptor; /** * Trading same assets is not allowed. */ NotAllowed: PlainDescriptor; }; DynamicFees: { /** * Invalid fee parameters provided */ InvalidFeeParameters: PlainDescriptor; }; Staking: { /** * Balance is too low. */ InsufficientBalance: PlainDescriptor; /** * Staked amount is too low. */ InsufficientStake: PlainDescriptor; /** * Staking position has not been found. */ PositionNotFound: PlainDescriptor; /** * Maximum amount of votes were reached for staking position. */ MaxVotesReached: PlainDescriptor; /** * Staking is not initialized. */ NotInitialized: PlainDescriptor; /** * Staking is already initialized. */ AlreadyInitialized: PlainDescriptor; /** * Arithmetic error. */ Arithmetic: PlainDescriptor; /** * Pot's balance is zero. */ MissingPotBalance: PlainDescriptor; /** * Account's position already exists. */ PositionAlreadyExists: PlainDescriptor; /** * Signer is not an owner of the staking position. */ Forbidden: PlainDescriptor; /** * Position contains registered votes. */ ExistingVotes: PlainDescriptor; /** * Position contains processed votes. Removed these votes first before increasing stake or claiming. */ ExistingProcessedVotes: PlainDescriptor; /** * Action cannot be completed because unexpected error has occurred. This should be reported * to protocol maintainers. */ InconsistentState: PlainDescriptor>; }; Stableswap: { /** * Creating a pool with same assets or less than 2 assets is not allowed. */ IncorrectAssets: PlainDescriptor; /** * Maximum number of assets has been exceeded. */ MaxAssetsExceeded: PlainDescriptor; /** * A pool with given assets does not exist. */ PoolNotFound: PlainDescriptor; /** * A pool with given assets already exists. */ PoolExists: PlainDescriptor; /** * Asset is not in the pool. */ AssetNotInPool: PlainDescriptor; /** * Share asset is not registered in Registry. */ ShareAssetNotRegistered: PlainDescriptor; /** * Share asset is amount assets when creating a pool. */ ShareAssetInPoolAssets: PlainDescriptor; /** * One or more assets are not registered in AssetRegistry */ AssetNotRegistered: PlainDescriptor; /** * Invalid asset amount provided. Amount must be greater than zero. */ InvalidAssetAmount: PlainDescriptor; /** * Balance of an asset is not sufficient to perform a trade. */ InsufficientBalance: PlainDescriptor; /** * Balance of a share asset is not sufficient to withdraw liquidity. */ InsufficientShares: PlainDescriptor; /** * Liquidity has not reached the required minimum. */ InsufficientLiquidity: PlainDescriptor; /** * Insufficient liquidity left in the pool after withdrawal. */ InsufficientLiquidityRemaining: PlainDescriptor; /** * Amount is less than the minimum trading amount configured. */ InsufficientTradingAmount: PlainDescriptor; /** * Minimum limit has not been reached during trade. */ BuyLimitNotReached: PlainDescriptor; /** * Maximum limit has been exceeded during trade. */ SellLimitExceeded: PlainDescriptor; /** * Initial liquidity of asset must be > 0. */ InvalidInitialLiquidity: PlainDescriptor; /** * Amplification is outside configured range. */ InvalidAmplification: PlainDescriptor; /** * Remaining balance of share asset is below asset's existential deposit. */ InsufficientShareBalance: PlainDescriptor; /** * Not allowed to perform an operation on given asset. */ NotAllowed: PlainDescriptor; /** * Future block number is in the past. */ PastBlock: PlainDescriptor; /** * New amplification is equal to the previous value. */ SameAmplification: PlainDescriptor; /** * Slippage protection. */ SlippageLimit: PlainDescriptor; /** * Failed to retrieve asset decimals. */ UnknownDecimals: PlainDescriptor; /** * List of provided pegs is incorrect. */ IncorrectInitialPegs: PlainDescriptor; /** * Failed to retrieve oracle entry. */ MissingTargetPegOracle: PlainDescriptor; /** * Creating pool with pegs is not allowed for asset with different decimals. */ IncorrectAssetDecimals: PlainDescriptor; /** * Pool does not have pegs configured. */ NoPegSource: PlainDescriptor; /** * Trade would result in zero amount out. */ ZeroAmountOut: PlainDescriptor; /** * Trade would result in zero amount in. */ ZeroAmountIn: PlainDescriptor; }; Bonds: { /** * Bond not registered */ NotRegistered: PlainDescriptor; /** * Bond is not mature */ NotMature: PlainDescriptor; /** * Maturity not long enough */ InvalidMaturity: PlainDescriptor; /** * Asset type not allowed for underlying asset */ DisallowedAsset: PlainDescriptor; /** * Asset is not registered in `AssetRegistry` */ AssetNotFound: PlainDescriptor; /** * Generated name is not valid. */ InvalidBondName: PlainDescriptor; /** * Bond's name parsing was now successful */ FailToParseName: PlainDescriptor; }; OtcSettlements: { /** * Otc order not found */ OrderNotFound: PlainDescriptor; /** * OTC order is not partially fillable */ NotPartiallyFillable: PlainDescriptor; /** * Provided route doesn't match the existing route */ InvalidRoute: PlainDescriptor; /** * Initial and final balance are different */ BalanceInconsistency: PlainDescriptor; /** * Trade amount higher than necessary */ TradeAmountTooHigh: PlainDescriptor; /** * Trade amount lower than necessary */ TradeAmountTooLow: PlainDescriptor; /** * Price for a route is not available */ PriceNotAvailable: PlainDescriptor; }; LBP: { /** * Pool assets can not be the same */ CannotCreatePoolWithSameAssets: PlainDescriptor; /** * Account is not a pool owner */ NotOwner: PlainDescriptor; /** * Sale already started */ SaleStarted: PlainDescriptor; /** * Sale is still in progress */ SaleNotEnded: PlainDescriptor; /** * Sale is not running */ SaleIsNotRunning: PlainDescriptor; /** * Sale duration is too long */ MaxSaleDurationExceeded: PlainDescriptor; /** * Liquidity being added should not be zero */ CannotAddZeroLiquidity: PlainDescriptor; /** * Asset balance too low */ InsufficientAssetBalance: PlainDescriptor; /** * Pool does not exist */ PoolNotFound: PlainDescriptor; /** * Pool has been already created */ PoolAlreadyExists: PlainDescriptor; /** * Invalid block range */ InvalidBlockRange: PlainDescriptor; /** * Calculation error */ WeightCalculationError: PlainDescriptor; /** * Weight set is out of range */ InvalidWeight: PlainDescriptor; /** * Can not perform a trade with zero amount */ ZeroAmount: PlainDescriptor; /** * Trade amount is too high */ MaxInRatioExceeded: PlainDescriptor; /** * Trade amount is too high */ MaxOutRatioExceeded: PlainDescriptor; /** * Invalid fee amount */ FeeAmountInvalid: PlainDescriptor; /** * Trading limit reached */ TradingLimitReached: PlainDescriptor; /** * An unexpected integer overflow occurred */ Overflow: PlainDescriptor; /** * Nothing to update */ NothingToUpdate: PlainDescriptor; /** * Liquidity has not reached the required minimum. */ InsufficientLiquidity: PlainDescriptor; /** * Amount is less than minimum trading limit. */ InsufficientTradingAmount: PlainDescriptor; /** * Not more than one fee collector per asset id */ FeeCollectorWithAssetAlreadyUsed: PlainDescriptor; }; XYK: { /** * It is not allowed to create a pool between same assets. */ CannotCreatePoolWithSameAssets: PlainDescriptor; /** * Liquidity has not reached the required minimum. */ InsufficientLiquidity: PlainDescriptor; /** * Amount is less than min trading limit. */ InsufficientTradingAmount: PlainDescriptor; /** * Liquidity is zero. */ ZeroLiquidity: PlainDescriptor; /** * Overflow */ InvalidMintedLiquidity: PlainDescriptor; /** * Overflow */ InvalidLiquidityAmount: PlainDescriptor; /** * Asset amount has exceeded given limit. */ AssetAmountExceededLimit: PlainDescriptor; /** * Asset amount has not reached given limit. */ AssetAmountNotReachedLimit: PlainDescriptor; /** * Asset balance is not sufficient. */ InsufficientAssetBalance: PlainDescriptor; /** * Not enough asset liquidity in the pool. */ InsufficientPoolAssetBalance: PlainDescriptor; /** * Not enough core asset liquidity in the pool. */ InsufficientNativeCurrencyBalance: PlainDescriptor; /** * Liquidity pool for given assets does not exist. */ TokenPoolNotFound: PlainDescriptor; /** * Liquidity pool for given assets already exists. */ TokenPoolAlreadyExists: PlainDescriptor; /** * Overflow */ AddAssetAmountInvalid: PlainDescriptor; /** * Overflow */ RemoveAssetAmountInvalid: PlainDescriptor; /** * Overflow */ SellAssetAmountInvalid: PlainDescriptor; /** * Overflow */ BuyAssetAmountInvalid: PlainDescriptor; /** * Overflow */ FeeAmountInvalid: PlainDescriptor; /** * Max fraction of pool to buy in single transaction has been exceeded. */ MaxOutRatioExceeded: PlainDescriptor; /** * Max fraction of pool to sell in single transaction has been exceeded. */ MaxInRatioExceeded: PlainDescriptor; /** * Overflow */ Overflow: PlainDescriptor; /** * Pool cannot be created due to outside factors. */ CannotCreatePool: PlainDescriptor; /** * Slippage protection. */ SlippageLimit: PlainDescriptor; }; Referrals: { /** * Referral code is too long. */ TooLong: PlainDescriptor; /** * Referral code is too short. */ TooShort: PlainDescriptor; /** * Referral code contains invalid character. Only alphanumeric characters are allowed. */ InvalidCharacter: PlainDescriptor; /** * Referral code already exists. */ AlreadyExists: PlainDescriptor; /** * Provided referral code is invalid. Either does not exist or is too long. */ InvalidCode: PlainDescriptor; /** * Account is already linked to another referral account. */ AlreadyLinked: PlainDescriptor; /** * Nothing in the referral pot account for the asset. */ ZeroAmount: PlainDescriptor; /** * Linking an account to the same referral account is not allowed. */ LinkNotAllowed: PlainDescriptor; /** * Calculated rewards are more than the fee amount. This can happen if percentages are incorrectly set. */ IncorrectRewardCalculation: PlainDescriptor; /** * Given referrer and trader percentages exceeds 100% percent. */ IncorrectRewardPercentage: PlainDescriptor; /** * The account has already a code registered. */ AlreadyRegistered: PlainDescriptor; /** * Price for given asset pair not found. */ PriceNotFound: PlainDescriptor; /** * Minimum trading amount for conversion has not been reached. */ ConversionMinTradingAmountNotReached: PlainDescriptor; /** * Zero amount received from conversion. */ ConversionZeroAmountReceived: PlainDescriptor; }; Liquidation: { /** * AssetId to EVM address conversion failed */ AssetConversionFailed: PlainDescriptor; /** * Liquidation call failed */ LiquidationCallFailed: PlainDescriptor; /** * Provided route doesn't match the existing route */ InvalidRoute: PlainDescriptor; /** * Liquidation was not profitable enough to repay flash loan */ NotProfitable: PlainDescriptor; /** * Flash minter contract address not set. It is required for Hollar liquidations. */ FlashMinterNotSet: PlainDescriptor; /** * Invalid liquidation data provided */ InvalidLiquidationData: PlainDescriptor; }; HSM: { /** * Asset is not approved as collateral * * The operation attempted to use an asset that is not registered as an approved collateral. */ AssetNotApproved: PlainDescriptor; /** * Asset is already approved as collateral * * Attempted to add an asset that is already registered as a collateral. */ AssetAlreadyApproved: PlainDescriptor; /** * Another asset from the same pool is already approved * * Only one asset from each StableSwap pool can be used as collateral. */ PoolAlreadyHasCollateral: PlainDescriptor; /** * Invalid asset pair, must be Hollar and approved collateral * * The asset pair for buy/sell operations must include Hollar as one side and an approved collateral as the other. */ InvalidAssetPair: PlainDescriptor; /** * Max buy price exceeded * * The calculated buy price exceeds the maximum allowed buy price for the collateral. */ MaxBuyPriceExceeded: PlainDescriptor; /** * Max buy back amount in single block exceeded * * The amount of Hollar being sold to HSM exceeds the maximum allowed in a single block for this collateral. */ MaxBuyBackExceeded: PlainDescriptor; /** * Max holding amount for collateral exceeded * * The operation would cause the HSM to hold more of the collateral than the configured maximum. */ MaxHoldingExceeded: PlainDescriptor; /** * Slippage limit exceeded * * The calculated amount is worse than the provided slippage limit. */ SlippageLimitExceeded: PlainDescriptor; /** * Invalid EVM contract interaction * * The call to the EVM contract (GHO Hollar token) failed. */ InvalidEVMInteraction: PlainDescriptor; /** * Decimal retrieval failed * * Failed to retrieve the decimal information for an asset. */ DecimalRetrievalFailed: PlainDescriptor; /** * No arbitrage opportunity * * There is no profitable arbitrage opportunity for the specified collateral. */ NoArbitrageOpportunity: PlainDescriptor; /** * Asset not in the pool * * The specified asset was not found in the pool. */ AssetNotFound: PlainDescriptor; /** * Provided pool state is invalid * * The retrieved pool state has inconsistent or invalid data. */ InvalidPoolState: PlainDescriptor; /** * Collateral is not empty * * Cannot remove a collateral asset that still has a non-zero balance in the HSM account. */ CollateralNotEmpty: PlainDescriptor; /** * Asset not in the pool * * The collateral asset is not present in the specified pool. */ AssetNotInPool: PlainDescriptor; /** * Hollar is not in the pool * * The Hollar asset is not present in the specified pool. */ HollarNotInPool: PlainDescriptor; /** * Insufficient collateral balance * * The HSM does not have enough of the collateral asset to complete the operation. */ InsufficientCollateralBalance: PlainDescriptor; /** * GHO Contract address not found * * The EVM address for the GHO (Hollar) token contract was not found. */ HollarContractAddressNotFound: PlainDescriptor; /** * HSM contains maximum number of allowed collateral assets. */ MaxNumberOfCollateralsReached: PlainDescriptor; /** * Flash minter address not set */ FlashMinterNotSet: PlainDescriptor; /** * Provided arbitrage data is invalid */ InvalidArbitrageData: PlainDescriptor; }; Signet: { /** * The pallet has already been initialized */ AlreadyInitialized: PlainDescriptor; /** * The pallet has not been initialized yet */ NotInitialized: PlainDescriptor; /** * Unauthorized - caller is not admin */ Unauthorized: PlainDescriptor; /** * Insufficient funds for withdrawal */ InsufficientFunds: PlainDescriptor; /** * Invalid transaction data (empty) */ InvalidTransaction: PlainDescriptor; /** * Arrays must have the same length */ InvalidInputLength: PlainDescriptor; /** * The chain ID is too long */ ChainIdTooLong: PlainDescriptor; /** * Transaction data exceeds maximum allowed length */ DataTooLong: PlainDescriptor; /** * Invalid address format - must be exactly 20 bytes */ InvalidAddress: PlainDescriptor; /** * Priority fee cannot exceed max fee per gas (EIP-1559 requirement) */ InvalidGasPrice: PlainDescriptor; /** * Signature Deposit cannot exceed MaxSignatureDeposit */ MaxDepositExceeded: PlainDescriptor; }; EthDispenser: { /** * Request ID has already been used. */ DuplicateRequest: PlainDescriptor; /** * Failed to (de)serialize data. */ Serialization: PlainDescriptor; /** * Output data did not match the expected format. */ InvalidOutput: PlainDescriptor; /** * Request ID does not match the derived ID for the provided data. */ InvalidRequestId: PlainDescriptor; /** * Pallet is paused and cannot process this call. */ Paused: PlainDescriptor; /** * Requested amount is below the configured minimum. */ AmountTooSmall: PlainDescriptor; /** * Requested amount exceeds the configured maximum. */ AmountTooLarge: PlainDescriptor; /** * EVM address parameter is invalid (e.g., zero address). */ InvalidAddress: PlainDescriptor; /** * Faucet balance would fall below the configured threshold after this request. */ FaucetBalanceBelowThreshold: PlainDescriptor; /** * Caller does not have enough balance of the fee asset. */ NotEnoughFeeFunds: PlainDescriptor; /** * Caller does not have enough balance of the faucet asset. */ NotEnoughFaucetFunds: PlainDescriptor; }; Tokens: { /** * The balance is too low */ BalanceTooLow: PlainDescriptor; /** * Cannot convert Amount into Balance type */ AmountIntoBalanceFailed: PlainDescriptor; /** * Failed because liquidity restrictions due to locking */ LiquidityRestrictions: PlainDescriptor; /** * Failed because the maximum locks was exceeded */ MaxLocksExceeded: PlainDescriptor; /** * Transfer/payment would kill account */ KeepAlive: PlainDescriptor; /** * Value too low to create account due to existential deposit */ ExistentialDeposit: PlainDescriptor; /** * Beneficiary account must pre-exist */ DeadAccount: PlainDescriptor; /** */ TooManyReserves: PlainDescriptor; }; Currencies: { /** * Unable to convert the Amount type into Balance. */ AmountIntoBalanceFailed: PlainDescriptor; /** * Balance is too low. */ BalanceTooLow: PlainDescriptor; /** * Deposit result is not expected */ DepositFailed: PlainDescriptor; /** * Operation is not supported for this currency */ NotSupported: PlainDescriptor; }; Vesting: { /** * Vesting period is zero */ ZeroVestingPeriod: PlainDescriptor; /** * Number of vests is zero */ ZeroVestingPeriodCount: PlainDescriptor; /** * Insufficient amount of balance to lock */ InsufficientBalanceToLock: PlainDescriptor; /** * This account have too many vesting schedules */ TooManyVestingSchedules: PlainDescriptor; /** * The vested transfer amount is too low */ AmountLow: PlainDescriptor; /** * Failed because the maximum vesting schedules was exceeded */ MaxVestingSchedulesExceeded: PlainDescriptor; }; EVM: { /** * Not enough balance to perform action */ BalanceLow: PlainDescriptor; /** * Calculating total fee overflowed */ FeeOverflow: PlainDescriptor; /** * Calculating total payment overflowed */ PaymentOverflow: PlainDescriptor; /** * Withdraw fee failed */ WithdrawFailed: PlainDescriptor; /** * Gas price is too low. */ GasPriceTooLow: PlainDescriptor; /** * Nonce is invalid */ InvalidNonce: PlainDescriptor; /** * Gas limit is too low. */ GasLimitTooLow: PlainDescriptor; /** * Gas limit is too high. */ GasLimitTooHigh: PlainDescriptor; /** * The chain id is invalid. */ InvalidChainId: PlainDescriptor; /** * the signature is invalid. */ InvalidSignature: PlainDescriptor; /** * EVM reentrancy */ Reentrancy: PlainDescriptor; /** * EIP-3607, */ TransactionMustComeFromEOA: PlainDescriptor; /** * Undefined error. */ Undefined: PlainDescriptor; /** * Address not allowed to deploy contracts either via CREATE or CALL(CREATE). */ CreateOriginNotAllowed: PlainDescriptor; }; Ethereum: { /** * Signature is invalid. */ InvalidSignature: PlainDescriptor; /** * Pre-log is present, therefore transact is not allowed. */ PreLogExists: PlainDescriptor; }; EVMAccounts: { /** * Active EVM account cannot be bound */ TruncatedAccountAlreadyUsed: PlainDescriptor; /** * Address is already bound */ AddressAlreadyBound: PlainDescriptor; /** * Bound address cannot be used */ BoundAddressCannotBeUsed: PlainDescriptor; /** * Address not whitelisted */ AddressNotWhitelisted: PlainDescriptor; /** * Provided signature is invalid */ InvalidSignature: PlainDescriptor; /** * Account already exists in the system pallet */ AccountAlreadyExists: PlainDescriptor; /** * Insufficient asset balance of the claimed asset */ InsufficientAssetBalance: PlainDescriptor; }; XYKLiquidityMining: { /** * Nft pallet didn't return an owner. */ CantFindDepositOwner: PlainDescriptor; /** * Account balance of XYK pool shares is not sufficient. */ InsufficientXykSharesBalance: PlainDescriptor; /** * XYK pool does not exist */ XykPoolDoesntExist: PlainDescriptor; /** * Account is not deposit owner. */ NotDepositOwner: PlainDescriptor; /** * XYK did not return assets for given pool id */ CantGetXykAssets: PlainDescriptor; /** * Deposit data not found */ DepositDataNotFound: PlainDescriptor; /** * Calculated reward to claim is 0. */ ZeroClaimedRewards: PlainDescriptor; /** * Asset is not in the `AssetPair`. */ AssetNotInAssetPair: PlainDescriptor; /** * Provided `AssetPair` is not used by the deposit. */ InvalidAssetPair: PlainDescriptor; /** * Asset is not registered in asset registry. */ AssetNotRegistered: PlainDescriptor; /** * Failed to calculate `pot`'s account. */ FailToGetPotId: PlainDescriptor; /** * No global farm - yield farm pairs specified to join */ NoFarmsSpecified: PlainDescriptor; /** * Failed to calculate value of xyk shares */ FailedToValueShares: PlainDescriptor; }; XYKWarehouseLM: { /** * Global farm does not exist. */ GlobalFarmNotFound: PlainDescriptor; /** * Yield farm does not exist. */ YieldFarmNotFound: PlainDescriptor; /** * Multiple claims in the same period is not allowed. */ DoubleClaimInPeriod: PlainDescriptor; /** * Liquidity mining is canceled. */ LiquidityMiningCanceled: PlainDescriptor; /** * Liquidity mining is not canceled. */ LiquidityMiningIsActive: PlainDescriptor; /** * Liquidity mining is in `active` or `terminated` state and action cannot be completed. */ LiquidityMiningIsNotStopped: PlainDescriptor; /** * Account is not allowed to perform action. */ Forbidden: PlainDescriptor; /** * Yield farm multiplier can't be 0. */ InvalidMultiplier: PlainDescriptor; /** * Yield farm with given `amm_pool_id` already exists in global farm. */ YieldFarmAlreadyExists: PlainDescriptor; /** * Loyalty curve's initial reward percentage is not valid. Valid range is: [0, 1). */ InvalidInitialRewardPercentage: PlainDescriptor; /** * One or more yield farms exist in global farm. */ GlobalFarmIsNotEmpty: PlainDescriptor; /** * Farm's `incentivized_asset` is missing in provided asset pair. */ MissingIncentivizedAsset: PlainDescriptor; /** * Reward currency balance is not sufficient. */ InsufficientRewardCurrencyBalance: PlainDescriptor; /** * Blocks per period can't be 0. */ InvalidBlocksPerPeriod: PlainDescriptor; /** * Yield per period can't be 0. */ InvalidYieldPerPeriod: PlainDescriptor; /** * Total rewards is less than `MinTotalFarmRewards`. */ InvalidTotalRewards: PlainDescriptor; /** * Planned yielding periods is less than `MinPlannedYieldingPeriods`. */ InvalidPlannedYieldingPeriods: PlainDescriptor; /** * Maximum number of locks reached for deposit. */ MaxEntriesPerDeposit: PlainDescriptor; /** * Trying to lock LP shares into already locked yield farm. */ DoubleLock: PlainDescriptor; /** * Yield farm entry doesn't exist for given deposit. */ YieldFarmEntryNotFound: PlainDescriptor; /** * Max number of yield farms in global farm was reached. Global farm can't accept new * yield farms until some yield farm is not removed from storage. */ GlobalFarmIsFull: PlainDescriptor; /** * Invalid min. deposit was set for global farm. */ InvalidMinDeposit: PlainDescriptor; /** * Price adjustment multiplier can't be 0. */ InvalidPriceAdjustment: PlainDescriptor; /** * Account creation from id failed. */ ErrorGetAccountId: PlainDescriptor; /** * Value of deposited shares amount in reward currency is bellow min. limit. */ IncorrectValuedShares: PlainDescriptor; /** * `reward_currency` is not registered in asset registry. */ RewardCurrencyNotRegistered: PlainDescriptor; /** * `incentivized_asset` is not registered in asset registry. */ IncentivizedAssetNotRegistered: PlainDescriptor; /** * Provided `amm_pool_id` doesn't match deposit's `amm_pool_id`. */ AmmPoolIdMismatch: PlainDescriptor; /** * Action cannot be completed because unexpected error has occurred. This should be reported * to protocol maintainers. */ InconsistentState: PlainDescriptor>; }; DCA: { /** * Schedule not exist */ ScheduleNotFound: PlainDescriptor; /** * The min trade amount is not reached */ MinTradeAmountNotReached: PlainDescriptor; /** * Forbidden as the user is not the owner of the schedule */ Forbidden: PlainDescriptor; /** * The next execution block number is not in the future */ BlockNumberIsNotInFuture: PlainDescriptor; /** * Price is unstable as price change from oracle data is bigger than max allowed */ PriceUnstable: PlainDescriptor; /** * Order was randomly rescheduled to next block */ Bumped: PlainDescriptor; /** * Error occurred when calculating price */ CalculatingPriceError: PlainDescriptor; /** * The total amount to be reserved is smaller than min budget */ TotalAmountIsSmallerThanMinBudget: PlainDescriptor; /** * The budget is too low for executing at least two orders */ BudgetTooLow: PlainDescriptor; /** * There is no free block found to plan DCA execution */ NoFreeBlockFound: PlainDescriptor; /** * The DCA schedule has been manually terminated */ ManuallyTerminated: PlainDescriptor; /** * Max number of retries reached for schedule */ MaxRetryReached: PlainDescriptor; /** * Absolutely trade limit reached, leading to retry */ TradeLimitReached: PlainDescriptor; /** * Slippage limit calculated from oracle is reached, leading to retry */ SlippageLimitReached: PlainDescriptor; /** * No parent hash has been found from relay chain */ NoParentHashFound: PlainDescriptor; /** * Error that should not really happen only in case of invalid state of the schedule storage entries */ InvalidState: PlainDescriptor; /** * Period should be longer than 5 blocks */ PeriodTooShort: PlainDescriptor; /** * Stability threshold cannot be higher than `MaxConfigurablePriceDifferenceBetweenBlock` */ StabilityThresholdTooHigh: PlainDescriptor; /** * User still has active DCA schedules and cannot unlock reserves */ HasActiveSchedules: PlainDescriptor; /** * No reserves are locked for the user for the given asset */ NoReservesLocked: PlainDescriptor; }; Scheduler: { /** * Failed to schedule a call */ FailedToSchedule: PlainDescriptor; /** * Cannot find the scheduled call. */ NotFound: PlainDescriptor; /** * Given target block number is in the past. */ TargetBlockNumberInPast: PlainDescriptor; /** * Reschedule failed because it does not change scheduled time. */ RescheduleNoChange: PlainDescriptor; /** * Attempt to use a non-named function on a named task. */ Named: 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; }; 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; }; 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; }; 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; }; MultiBlockMigrations: { /** * The operation cannot complete since some MBMs are ongoing. */ Ongoing: PlainDescriptor; }; OrmlXcm: { /** * The message and destination combination was not recognized as being * reachable. */ Unreachable: PlainDescriptor; /** * The message and destination was recognized as being reachable but * the operation could not be completed. */ SendFailure: PlainDescriptor; /** * The version of the `Versioned` value used is not able to be * interpreted. */ BadVersion: PlainDescriptor; }; XTokens: { /** * Asset has no reserve location. */ AssetHasNoReserve: PlainDescriptor; /** * Not cross-chain transfer. */ NotCrossChainTransfer: PlainDescriptor; /** * Invalid transfer destination. */ InvalidDest: PlainDescriptor; /** * Currency is not cross-chain transferable. */ NotCrossChainTransferableCurrency: PlainDescriptor; /** * The message's weight could not be determined. */ UnweighableMessage: PlainDescriptor; /** * XCM execution failed. */ XcmExecutionFailed: PlainDescriptor; /** * Could not re-anchor the assets to declare the fees for the * destination chain. */ CannotReanchor: PlainDescriptor; /** * Could not get ancestry of asset reserve location. */ InvalidAncestry: PlainDescriptor; /** * The Asset is invalid. */ InvalidAsset: PlainDescriptor; /** * The destination `Location` provided cannot be inverted. */ DestinationNotInvertible: PlainDescriptor; /** * The version of the `Versioned` value used is not able to be * interpreted. */ BadVersion: PlainDescriptor; /** * We tried sending distinct asset and fee but they have different * reserve chains. */ DistinctReserveForAssetAndFee: PlainDescriptor; /** * The fee is zero. */ ZeroFee: PlainDescriptor; /** * The transferring asset amount is zero. */ ZeroAmount: PlainDescriptor; /** * The number of assets to be sent is over the maximum. */ TooManyAssetsBeingSent: PlainDescriptor; /** * The specified index does not exist in a Assets struct. */ AssetIndexNonExistent: PlainDescriptor; /** * Fee is not enough. */ FeeNotEnough: PlainDescriptor; /** * Not supported Location */ NotSupportedLocation: PlainDescriptor; /** * MinXcmFee not registered for certain reserve location */ MinXcmFeeNotDefined: PlainDescriptor; /** * Asset transfer is limited by RateLimiter. */ RateLimited: PlainDescriptor; }; UnknownTokens: { /** * The balance is too low. */ BalanceTooLow: PlainDescriptor; /** * The operation will cause balance to overflow. */ BalanceOverflow: PlainDescriptor; /** * Unhandled asset. */ UnhandledAsset: 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; }; EmaOracle: { /** */ TooManyUniqueEntries: PlainDescriptor; /** */ OnTradeValueZero: PlainDescriptor; /** */ OracleNotFound: PlainDescriptor; /** * Asset not found */ AssetNotFound: PlainDescriptor; /** * The new price is outside the max allowed range */ PriceOutsideAllowedRange: PlainDescriptor; }; Broadcast: { /** * The execution context call stack has reached its maximum size */ ExecutionCallStackOverflow: PlainDescriptor; /** * The execution context call stack is empty, unable to decrease level */ ExecutionCallStackUnderflow: 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; }; 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; }; Proxy: { /** * The base amount of currency needed to reserve for creating a proxy. * * This is held for an additional storage item whose value size is * `sizeof(Balance)` bytes and whose key size is `sizeof(AccountId)` bytes. */ ProxyDepositBase: PlainDescriptor; /** * The amount of currency needed per proxy added. * * This is held for adding 32 bytes plus an instance of `ProxyType` more into a * pre-existing storage value. Thus, when configuring `ProxyDepositFactor` one should take * into account `32 + proxy_type.encode().len()` bytes of data. */ ProxyDepositFactor: PlainDescriptor; /** * The maximum amount of proxies allowed for a single account. */ MaxProxies: PlainDescriptor; /** * The maximum amount of time-delayed announcements that are allowed to be pending. */ MaxPending: PlainDescriptor; /** * The base amount of currency needed to reserve for creating an announcement. * * This is held when a new storage item holding a `Balance` is created (typically 16 * bytes). */ AnnouncementDepositBase: PlainDescriptor; /** * The amount of currency needed per announcement made. * * This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes) * into a pre-existing storage value. */ AnnouncementDepositFactor: PlainDescriptor; }; Multisig: { /** * The base amount of currency needed to reserve for creating a multisig execution or to * store a dispatch call for later. * * This is held for an additional storage item whose value size is * `4 + sizeof((BlockNumber, Balance, AccountId))` bytes and whose key size is * `32 + sizeof(AccountId)` bytes. */ DepositBase: PlainDescriptor; /** * The amount of currency needed per unit threshold when creating a multisig execution. * * This is held for adding 32 bytes more into a pre-existing storage value. */ DepositFactor: PlainDescriptor; /** * The maximum amount of signatories allowed in the multisig. */ MaxSignatories: PlainDescriptor; }; Referenda: { /** * The minimum amount to be used as a deposit for a public referendum proposal. */ SubmissionDeposit: PlainDescriptor; /** * Maximum size of the referendum queue for a single track. */ MaxQueued: PlainDescriptor; /** * The number of blocks after submission that a referendum must begin being decided by. * Once this passes, then anyone may cancel the referendum. */ UndecidingTimeout: PlainDescriptor; /** * Quantization level for the referendum wakeup scheduler. A higher number will result in * fewer storage reads/writes needed for smaller voters, but also result in delays to the * automatic referendum status changes. Explicit servicing instructions are unaffected. */ AlarmInterval: PlainDescriptor; /** * A list of tracks. * * Note: if the tracks are dynamic, the value in the static metadata might be inaccurate. */ Tracks: PlainDescriptor>; }; Omnipool: { /** * Native Asset ID */ HdxAssetId: PlainDescriptor; /** * Hub Asset ID */ HubAssetId: PlainDescriptor; /** * Minimum withdrawal fee */ MinWithdrawalFee: PlainDescriptor; /** * Minimum trading limit */ MinimumTradingLimit: PlainDescriptor; /** * Minimum pool liquidity which can be added */ MinimumPoolLiquidity: PlainDescriptor; /** * Max fraction of asset reserve to sell in single transaction */ MaxInRatio: PlainDescriptor; /** * Max fraction of asset reserve to buy in single transaction */ MaxOutRatio: PlainDescriptor; /** * Non fungible class id */ NFTCollectionId: PlainDescriptor; /** */ BurnProtocolFee: PlainDescriptor; /** * Destination account when hub asset is sold */ HubDestination: PlainDescriptor; }; OmnipoolLiquidityMining: { /** * NFT collection id for liquidity mining's deposit nfts. */ NFTCollectionId: PlainDescriptor; /** * Identifier of oracle data soruce */ OracleSource: PlainDescriptor>; /** * Oracle's price aggregation period. */ OraclePeriod: PlainDescriptor>; }; OTC: { /** * Multiplier used to compute minimal amounts of asset_in and asset_out in an OTC. */ ExistentialDepositMultiplier: PlainDescriptor; /** * Fee deducted from amount_out. */ Fee: PlainDescriptor; /** * Fee receiver. */ FeeReceiver: PlainDescriptor; }; CircuitBreaker: { /** * The maximum percentage of a pool's liquidity that can be traded in a block. * Represented as a non-zero fraction (nominator, denominator) with the max value being 10_000. */ DefaultMaxNetTradeVolumeLimitPerBlock: PlainDescriptor>; /** * The maximum percentage of a pool's liquidity that can be added in a block. * Represented as an optional non-zero fraction (nominator, denominator) with the max value being 10_000. * If set to None, the limits are not enforced. */ DefaultMaxAddLiquidityLimitPerBlock: PlainDescriptor>; /** * The maximum percentage of a pool's liquidity that can be removed in a block. * Represented as an optional non-zero fraction (nominator, denominator) with the max value being 10_000. * If set to None, the limits are not enforced. */ DefaultMaxRemoveLiquidityLimitPerBlock: PlainDescriptor>; }; DynamicFees: { /** */ AssetFeeParameters: PlainDescriptor>; /** */ ProtocolFeeParameters: PlainDescriptor>; }; Staking: { /** * Staking period length in blocks. */ PeriodLength: PlainDescriptor; /** * Pallet id. */ PalletId: PlainDescriptor>; /** * Native Asset ID. */ NativeAssetId: PlainDescriptor; /** * Min amount user must stake. */ MinStake: PlainDescriptor; /** * Weight of the time points in total points calculations. */ TimePointsWeight: PlainDescriptor; /** * Weight of the action points in total points calculations. */ ActionPointsWeight: PlainDescriptor; /** * Number of time points users receive for each period. */ TimePointsPerPeriod: PlainDescriptor; /** * Number of periods user can't claim rewards for. User can exit but won't receive any rewards. * If he stay longer than `UnclaimablePeriods` he will receive rewards also for these periods. */ UnclaimablePeriods: PlainDescriptor; /** * Weight of the actual stake in slash points calculation. Bigger the value lower the calculated slash points. */ CurrentStakeWeight: PlainDescriptor; /** * Max amount of votes the user can have at any time. */ MaxVotes: PlainDescriptor; /** * NFT collection id. */ NFTCollectionId: PlainDescriptor; }; Stableswap: { /** * Minimum pool liquidity */ MinPoolLiquidity: PlainDescriptor; /** * Minimum trading amount */ MinTradingLimit: PlainDescriptor; /** * Amplification inclusive range. Pool's amp can be selected from the range only. */ AmplificationRange: PlainDescriptor>; }; LBP: { /** * Minimum trading limit, sole purpose of this is to keep the math working */ MinTradingLimit: PlainDescriptor; /** * Minimum pool liquidity, sole purpose of this is to keep the math working */ MinPoolLiquidity: PlainDescriptor; /** * Max fraction of pool to sell in single transaction */ MaxInRatio: PlainDescriptor; /** * Max fraction of pool to buy in single transaction */ MaxOutRatio: PlainDescriptor; /** */ repay_fee: PlainDescriptor>; }; XYK: { /** * Native Asset Id */ NativeAssetId: PlainDescriptor; /** * Trading fee rate */ GetExchangeFee: PlainDescriptor>; /** * Minimum trading limit */ MinTradingLimit: PlainDescriptor; /** * Minimum pool liquidity */ MinPoolLiquidity: PlainDescriptor; /** * Max fraction of pool to sell in single transaction */ MaxInRatio: PlainDescriptor; /** * Max fraction of pool to buy in single transaction */ MaxOutRatio: PlainDescriptor; /** * Oracle source identifier for this pallet. */ OracleSource: PlainDescriptor>; }; HSM: { /** * Asset ID of Hollar */ HollarId: PlainDescriptor; /** * Pallet ID to determine HSM account */ PalletId: PlainDescriptor>; /** */ MinArbitrageAmount: PlainDescriptor; /** */ FlashLoanReceiver: PlainDescriptor>; /** * The gas limit for the execution of EVM calls */ GasLimit: PlainDescriptor; }; XYKLiquidityMining: { /** * NFT collection id for liquidity mining's deposit nfts. */ NFTCollectionId: PlainDescriptor; /** * Oracle source identifier for this pallet. */ OracleSource: PlainDescriptor>; /** * Oracle's liquidity aggregation period. */ OraclePeriod: PlainDescriptor>; }; DCA: { /** * Max price difference allowed between blocks */ MaxPriceDifferenceBetweenBlocks: PlainDescriptor; /** * Max configurable price difference allowed between blocks */ MaxConfigurablePriceDifferenceBetweenBlocks: PlainDescriptor; /** * The number of max schedules to be executed per block */ MaxSchedulePerBlock: PlainDescriptor; /** * The number of max retries in case of trade limit error */ MaxNumberOfRetriesOnError: PlainDescriptor; /** * Minimal period between executions */ MinimalPeriod: PlainDescriptor; /** * Chance of the random rescheduling */ BumpChance: PlainDescriptor; /** * Minimum trading limit for a single trade */ MinimumTradingLimit: PlainDescriptor; /** * Native Asset Id */ NativeAssetId: PlainDescriptor; /** * Polkadot Native Asset Id (DOT) */ PolkadotNativeAssetId: PlainDescriptor; /** * Minimum budget to be able to schedule a DCA, specified in native currency */ MinBudgetInNativeCurrency: PlainDescriptor; /** * The fee receiver for transaction fees */ FeeReceiver: PlainDescriptor; /** * Named reserve identifier to store named reserves for orders of each users */ NamedReserveId: PlainDescriptor>; }; Aura: { /** * The slot duration Aura should run with, expressed in milliseconds. * The effective value of this type should not change while the chain is running. * * For backwards compatibility either use [`MinimumPeriodTimesTwo`] or a const. */ SlotDuration: PlainDescriptor; }; }; type IViewFns = {}; type IRuntimeCalls = { /** * The `Metadata` api trait that returns metadata for the runtime. */ Metadata: { /** * Returns the metadata of a runtime. */ metadata: RuntimeDescriptor<[], Uint8Array>; /** * 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>; }; /** */ CurrenciesApi: { /** */ account: RuntimeDescriptor<[asset_id: number, who: SS58String], Anonymize>; /** */ accounts: RuntimeDescriptor<[who: SS58String], Anonymize>; /** */ free_balance: RuntimeDescriptor<[asset_id: number, who: SS58String], bigint>; /** */ minimum_balance: RuntimeDescriptor<[asset_id: number], bigint>; }; /** * API necessary for Ethereum-compatibility layer. */ EthereumRuntimeRPCApi: { /** * Returns runtime defined pallet_evm::ChainId. */ chain_id: RuntimeDescriptor<[], bigint>; /** * Returns pallet_evm::Accounts by address. */ account_basic: RuntimeDescriptor<[address: SizedHex<20>], Anonymize>; /** * Returns FixedGasPrice::min_gas_price */ gas_price: RuntimeDescriptor<[], Anonymize>; /** * For a given account address, returns pallet_evm::AccountCodes. */ account_code_at: RuntimeDescriptor<[address: SizedHex<20>], Uint8Array>; /** * Returns the converted FindAuthor::find_author authority id. */ author: RuntimeDescriptor<[], SizedHex<20>>; /** * For a given account address and index, returns pallet_evm::AccountStorages. */ storage_at: RuntimeDescriptor<[address: SizedHex<20>, index: Anonymize], SizedHex<32>>; /** */ call: RuntimeDescriptor<[from: SizedHex<20>, to: SizedHex<20>, data: Uint8Array, value: Anonymize, gas_limit: Anonymize, max_fee_per_gas: Anonymize, max_priority_fee_per_gas: Anonymize, nonce: Anonymize, estimate: boolean, access_list: Anonymize, authorization_list: Anonymize], Anonymize>; /** */ create: RuntimeDescriptor<[from: SizedHex<20>, data: Uint8Array, value: Anonymize, gas_limit: Anonymize, max_fee_per_gas: Anonymize, max_priority_fee_per_gas: Anonymize, nonce: Anonymize, estimate: boolean, access_list: Anonymize, authorization_list: Anonymize], Anonymize>; /** * Return the current block. */ current_block: RuntimeDescriptor<[], Anonymize>; /** * Return the current receipt. */ current_receipts: RuntimeDescriptor<[], Anonymize>; /** * Return the current transaction status. */ current_transaction_statuses: RuntimeDescriptor<[], Anonymize>; /** */ current_all: RuntimeDescriptor<[], Anonymize>; /** * Receives a `Vec` and filters all the ethereum transactions. */ extrinsic_filter: RuntimeDescriptor<[xts: Anonymize], Anonymize>; /** * Return the elasticity multiplier. */ elasticity: RuntimeDescriptor<[], Anonymize>; /** * Used to determine if gas limit multiplier for non-transactional calls (eth_call/estimateGas) * is supported. */ gas_limit_multiplier_support: RuntimeDescriptor<[], undefined>; /** * Return the pending block. */ pending_block: RuntimeDescriptor<[xts: Anonymize], Anonymize>; /** * Initialize the pending block. * The behavior should be the same as the runtime api Core_initialize_block but * for a "pending" block. * If your project don't need to have a different behavior to initialize "pending" blocks, * you can copy your Core_initialize_block implementation. */ initialize_pending_block: RuntimeDescriptor<[header: Anonymize], undefined>; }; /** * The API to query EVM account conversions. */ EvmAccountsApi: { /** * get the EVM address from the substrate address. */ evm_address: RuntimeDescriptor<[account_id: SS58String], SizedHex<20>>; /** * Return the Substrate address bound to the EVM account. If not bound, returns `None`. */ bound_account_id: RuntimeDescriptor<[evm_address: SizedHex<20>], Anonymize>; /** * Get the Substrate address from the EVM address. * Returns the truncated version of the address if the address wasn't bind. */ account_id: RuntimeDescriptor<[evm_address: SizedHex<20>], SS58String>; }; /** * 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>; /** * 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], 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>; }; /** */ AaveTradeExecutor: { /** */ pairs: RuntimeDescriptor<[], Anonymize>; /** */ liquidity_depth: RuntimeDescriptor<[asset_in: number, asset_out: number], Anonymize>; /** */ pool: RuntimeDescriptor<[reserve: number, atoken: number], Anonymize>; /** */ pools: RuntimeDescriptor<[], Anonymize>; }; }; export type HydrationNextDispatchError = unknown; type IAsset = PlainDescriptor; export type HydrationNextExtensions = {}; type PalletsTypedef = { __storage: IStorage; __tx: ICalls; __event: IEvent; __error: IError; __const: IConstants; __view: IViewFns; }; export type HydrationNext = { descriptors: { pallets: PalletsTypedef; apis: IRuntimeCalls; } & Promise; metadataTypes: Promise; asset: IAsset; extensions: HydrationNextExtensions; getMetadata: () => Promise; genesis: string | undefined; }; declare const _allDescriptors: HydrationNext; export default _allDescriptors; export type HydrationNextApis = ApisFromDef; export type HydrationNextQueries = QueryFromPalletsDef; export type HydrationNextCalls = TxFromPalletsDef; export type HydrationNextEvents = EventsFromPalletsDef; export type HydrationNextErrors = ErrorsFromPalletsDef; export type HydrationNextConstants = ConstFromPalletsDef; export type HydrationNextViewFns = ViewFnsFromPalletsDef; export type HydrationNextCallData = Anonymize & { value: { type: string; }; }; type AllInteractions = { storage: { System: ['Account', 'ExtrinsicCount', 'InherentsApplied', 'BlockWeight', 'AllExtrinsicsLen', 'BlockHash', 'ExtrinsicData', 'Number', 'ParentHash', 'Digest', 'Events', 'EventCount', 'EventTopics', 'LastRuntimeUpgrade', 'UpgradedToU32RefCount', 'UpgradedToTripleRefCount', 'ExecutionPhase', 'AuthorizedUpgrade', 'ExtrinsicWeightReclaimed']; Timestamp: ['Now', 'DidUpdate']; Balances: ['TotalIssuance', 'InactiveIssuance', 'Account', 'Locks', 'Reserves', 'Holds', 'Freezes']; TransactionPayment: ['NextFeeMultiplier', 'StorageVersion']; MultiTransactionPayment: ['AccountCurrencyMap', 'AcceptedCurrencies', 'AcceptedCurrencyPrice', 'TransactionCurrencyOverride']; Treasury: ['ProposalCount', 'Proposals', 'Deactivated', 'Approvals', 'SpendCount', 'Spends', 'LastSpendPeriod']; Preimage: ['StatusFor', 'RequestStatusFor', 'PreimageFor']; Identity: ['IdentityOf', 'UsernameOf', 'SuperOf', 'SubsOf', 'Registrars', 'AuthorityOf', 'UsernameInfoOf', 'PendingUsernames', 'UnbindingUsernames']; Democracy: ['PublicPropCount', 'PublicProps', 'DepositOf', 'ReferendumCount', 'LowestUnbaked', 'ReferendumInfoOf', 'VotingOf', 'LastTabledWasExternal', 'NextExternal', 'Blacklist', 'Cancellations', 'MetadataOf']; TechnicalCommittee: ['Proposals', 'ProposalOf', 'CostOf', 'Voting', 'ProposalCount', 'Members', 'Prime']; Proxy: ['Proxies', 'Announcements']; Multisig: ['Multisigs']; Uniques: ['Class', 'OwnershipAcceptance', 'Account', 'ClassAccount', 'Asset', 'ClassMetadataOf', 'InstanceMetadataOf', 'Attribute', 'ItemPriceOf', 'CollectionMaxSupply']; StateTrieMigration: ['MigrationProcess', 'AutoLimits', 'SignedMigrationMaxLimits']; ConvictionVoting: ['VotingFor', 'ClassLocksFor']; Referenda: ['ReferendumCount', 'ReferendumInfoFor', 'TrackQueue', 'DecidingCount', 'MetadataOf']; Whitelist: ['WhitelistedCall']; Dispatcher: ['AaveManagerAccount', 'ExtraGas', 'LastEvmCallExitReason']; AssetRegistry: ['Assets', 'NextAssetId', 'AssetIds', 'AssetLocations', 'BannedAssets', 'LocationAssets', 'ExistentialDepositCounter']; Claims: ['Claims']; GenesisHistory: ['PreviousChain']; CollatorRewards: ['Collators']; Omnipool: ['Assets', 'HubAssetTradability', 'Positions', 'NextPositionId', 'SlipFee', 'SlipFeeHubReserveAtBlockStart', 'SlipFeeDelta']; TransactionPause: ['PausedTransactions']; Duster: ['AccountWhitelist']; OmnipoolWarehouseLM: ['FarmSequencer', 'DepositSequencer', 'GlobalFarm', 'YieldFarm', 'Deposit', 'ActiveYieldFarm']; OmnipoolLiquidityMining: ['OmniPositionId']; OTC: ['NextOrderId', 'Orders']; CircuitBreaker: ['TradeVolumeLimitPerAsset', 'AllowedTradeVolumeLimitPerAsset', 'LiquidityAddLimitPerAsset', 'AllowedAddLiquidityAmountPerAsset', 'AssetLockdownState', 'LiquidityRemoveLimitPerAsset', 'AllowedRemoveLiquidityAmountPerAsset', 'GlobalWithdrawLimitConfig', 'WithdrawLimitAccumulator', 'WithdrawLockdownUntil', 'EgressAccounts', 'IgnoreWithdrawLimit', 'GlobalAssetOverrides']; Router: ['Routes']; DynamicFees: ['AssetFee', 'AssetFeeConfiguration']; Staking: ['Staking', 'Positions', 'NextPositionId', 'Votes', 'VotesRewarded', 'PositionVotes', 'ProcessedVotes', 'SixSecBlocksSince']; Stableswap: ['Pools', 'PoolPegs', 'AssetTradability', 'PoolSnapshots', 'BlockFee']; Bonds: ['BondIds', 'Bonds']; LBP: ['PoolData', 'FeeCollectorWithAsset']; XYK: ['ShareToken', 'TotalLiquidity', 'PoolAssets']; Referrals: ['ReferralCodes', 'ReferralAccounts', 'LinkedAccounts', 'ReferrerShares', 'TraderShares', 'TotalShares', 'Referrer', 'AssetRewards', 'PendingConversions', 'CounterForPendingConversions']; Liquidation: ['BorrowingContract']; HSM: ['Collaterals', 'HollarAmountReceived', 'FlashMinter']; Parameters: ['IsTestnet']; Signet: ['Admin', 'SignatureDeposit', 'ChainId']; EthDispenser: ['DispenserConfig', 'FaucetBalanceWei', 'UsedRequestIds']; Tokens: ['TotalIssuance', 'Locks', 'Accounts', 'Reserves']; Vesting: ['VestingSchedules']; EVM: ['AccountCodes', 'AccountCodesMetadata', 'AccountStorages']; EVMChainId: ['ChainId']; Ethereum: ['Pending', 'CounterForPending', 'CurrentBlock', 'CurrentReceipts', 'CurrentTransactionStatuses', 'BlockHash']; EVMAccounts: ['AccountExtension', 'ContractDeployer', 'ApprovedContract', 'MarkedEvmAccounts', 'Allowances']; DynamicEvmFee: ['BaseFeePerGas']; XYKWarehouseLM: ['FarmSequencer', 'DepositSequencer', 'GlobalFarm', 'YieldFarm', 'Deposit', 'ActiveYieldFarm']; DCA: ['ScheduleIdSequencer', 'Schedules', 'ScheduleOwnership', 'RemainingAmounts', 'RetriesOnError', 'ScheduleExecutionBlock', 'ScheduleIdsPerBlock', 'ScheduleExtraGas']; Scheduler: ['IncompleteSince', 'Agenda', 'Retries', 'Lookup']; ParachainSystem: ['UnincludedSegment', 'AggregatedUnincludedSegment', 'PendingValidationCode', 'NewValidationCode', 'ValidationData', 'DidSetValidationCode', 'LastRelayChainBlockNumber', 'UpgradeRestrictionSignal', 'UpgradeGoAhead', 'RelayStateProof', 'RelevantMessagingState', 'HostConfiguration', 'LastDmqMqcHead', 'LastHrmpMqcHeads', 'ProcessedDownwardMessages', 'HrmpWatermark', 'HrmpOutboundMessages', 'UpwardMessages', 'PendingUpwardMessages', 'UpwardDeliveryFeeFactor', 'AnnouncedHrmpMessagesPerCandidate', 'ReservedXcmpWeightOverride', 'ReservedDmpWeightOverride', 'CustomValidationHeadData']; ParachainInfo: ['ParachainId']; PolkadotXcm: ['QueryCounter', 'Queries', 'AssetTraps', 'SafeXcmVersion', 'SupportedVersion', 'VersionNotifiers', 'VersionNotifyTargets', 'VersionDiscoveryQueue', 'CurrentMigration', 'RemoteLockedFungibles', 'LockedFungibles', 'XcmExecutionSuspended', 'ShouldRecordXcm', 'RecordedXcm', 'AuthorizedAliases']; XcmpQueue: ['InboundXcmpSuspended', 'OutboundXcmpStatus', 'OutboundXcmpMessages', 'SignalMessages', 'QueueConfig', 'QueueSuspended', 'DeliveryFeeFactor']; MessageQueue: ['BookStateFor', 'ServiceHead', 'Pages']; MultiBlockMigrations: ['Cursor', 'Historic']; UnknownTokens: ['ConcreteFungibleBalances', 'AbstractFungibleBalances']; Authorship: ['Author']; CollatorSelection: ['Invulnerables', 'CandidateList', 'LastAuthoredBlock', 'DesiredCandidates', 'CandidacyBond']; Session: ['Validators', 'CurrentIndex', 'QueuedChanged', 'QueuedKeys', 'DisabledValidators', 'NextKeys', 'KeyOwner']; Aura: ['Authorities', 'CurrentSlot']; AuraExt: ['Authorities', 'RelaySlotInfo']; EmaOracle: ['Accumulator', 'Oracles', 'WhitelistedAssets']; Broadcast: ['IncrementalId', 'ExecutionContext', 'Swapper']; }; 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']; Timestamp: ['set']; Balances: ['transfer_allow_death', 'force_transfer', 'transfer_keep_alive', 'transfer_all', 'force_unreserve', 'upgrade_accounts', 'force_set_balance', 'force_adjust_total_issuance', 'burn']; MultiTransactionPayment: ['set_currency', 'add_currency', 'remove_currency', 'reset_payment_currency', 'dispatch_permit']; Treasury: ['spend_local', 'remove_approval', 'spend', 'payout', 'check_status', 'void_spend']; Utility: ['batch', 'as_derivative', 'batch_all', 'dispatch_as', 'force_batch', 'with_weight', 'if_else', 'dispatch_as_fallible']; Preimage: ['note_preimage', 'unnote_preimage', 'request_preimage', 'unrequest_preimage', 'ensure_updated']; Identity: ['add_registrar', 'set_identity', 'set_subs', 'clear_identity', 'request_judgement', 'cancel_request', 'set_fee', 'set_account_id', 'set_fields', 'provide_judgement', 'kill_identity', 'add_sub', 'rename_sub', 'remove_sub', 'quit_sub', 'add_username_authority', 'remove_username_authority', 'set_username_for', 'accept_username', 'remove_expired_approval', 'set_primary_username', 'unbind_username', 'remove_username', 'kill_username']; Democracy: ['propose', 'second', 'vote', 'emergency_cancel', 'external_propose', 'external_propose_majority', 'external_propose_default', 'fast_track', 'veto_external', 'cancel_referendum', 'delegate', 'undelegate', 'clear_public_proposals', 'unlock', 'remove_vote', 'remove_other_vote', 'blacklist', 'cancel_proposal', 'set_metadata', 'force_remove_vote']; TechnicalCommittee: ['set_members', 'execute', 'propose', 'vote', 'disapprove_proposal', 'close', 'kill', 'release_proposal_cost']; Proxy: ['proxy', 'add_proxy', 'remove_proxy', 'remove_proxies', 'create_pure', 'kill_pure', 'announce', 'remove_announcement', 'reject_announcement', 'proxy_announced', 'poke_deposit']; Multisig: ['as_multi_threshold_1', 'as_multi', 'approve_as_multi', 'cancel_as_multi', 'poke_deposit']; Uniques: ['create', 'force_create', 'destroy', 'mint', 'burn', 'transfer', 'redeposit', 'freeze', 'thaw', 'freeze_collection', 'thaw_collection', 'transfer_ownership', 'set_team', 'approve_transfer', 'cancel_approval', 'force_item_status', 'set_attribute', 'clear_attribute', 'set_metadata', 'clear_metadata', 'set_collection_metadata', 'clear_collection_metadata', 'set_accept_ownership', 'set_collection_max_supply', 'set_price', 'buy_item']; StateTrieMigration: ['control_auto_migration', 'continue_migrate', 'migrate_custom_top', 'migrate_custom_child', 'set_signed_max_limits', 'force_set_progress']; ConvictionVoting: ['vote', 'delegate', 'undelegate', 'unlock', 'remove_vote', 'remove_other_vote', 'force_remove_vote']; Referenda: ['submit', 'place_decision_deposit', 'refund_decision_deposit', 'cancel', 'kill', 'nudge_referendum', 'one_fewer_deciding', 'refund_submission_deposit', 'set_metadata']; Whitelist: ['whitelist_call', 'remove_whitelisted_call', 'dispatch_whitelisted_call', 'dispatch_whitelisted_call_with_preimage']; Dispatcher: ['dispatch_as_treasury', 'dispatch_as_aave_manager', 'note_aave_manager', 'dispatch_with_extra_gas', 'dispatch_evm_call']; AssetRegistry: ['register', 'update', 'register_external', 'ban_asset', 'unban_asset']; Claims: ['claim']; Omnipool: ['add_token', 'add_liquidity', 'add_liquidity_with_limit', 'remove_liquidity', 'remove_liquidity_with_limit', 'remove_all_liquidity', 'sacrifice_position', 'sell', 'buy', 'set_asset_tradable_state', 'refund_refused_asset', 'set_asset_weight_cap', 'withdraw_protocol_liquidity', 'remove_token', 'set_slip_fee']; TransactionPause: ['pause_transaction', 'unpause_transaction']; Duster: ['dust_account', 'whitelist_account', 'remove_from_whitelist']; OmnipoolLiquidityMining: ['create_global_farm', 'terminate_global_farm', 'create_yield_farm', 'update_yield_farm', 'stop_yield_farm', 'resume_yield_farm', 'terminate_yield_farm', 'deposit_shares', 'redeposit_shares', 'claim_rewards', 'withdraw_shares', 'update_global_farm', 'join_farms', 'add_liquidity_and_join_farms', 'exit_farms', 'add_liquidity_stableswap_omnipool_and_join_farms', 'remove_liquidity_stableswap_omnipool_and_exit_farms']; OTC: ['place_order', 'partial_fill_order', 'fill_order', 'cancel_order']; CircuitBreaker: ['set_trade_volume_limit', 'set_add_liquidity_limit', 'set_remove_liquidity_limit', 'lockdown_asset', 'force_lift_lockdown', 'release_deposit', 'set_global_withdraw_limit_params', 'reset_withdraw_lockdown', 'add_egress_accounts', 'remove_egress_accounts', 'set_global_withdraw_lockdown', 'set_asset_category']; Router: ['sell', 'buy', 'set_route', 'force_insert_route', 'sell_all']; DynamicFees: ['set_asset_fee', 'remove_asset_fee']; Staking: ['initialize_staking', 'stake', 'increase_stake', 'claim', 'unstake']; Stableswap: ['create_pool', 'update_pool_fee', 'update_amplification', 'add_liquidity_shares', 'remove_liquidity_one_asset', 'withdraw_asset_amount', 'sell', 'buy', 'set_asset_tradable_state', 'remove_liquidity', 'create_pool_with_pegs', 'add_assets_liquidity', 'update_asset_peg_source', 'update_pool_max_peg_update']; Bonds: ['issue', 'redeem']; OtcSettlements: ['settle_otc_order']; LBP: ['create_pool', 'update_pool_data', 'add_liquidity', 'remove_liquidity', 'sell', 'buy']; XYK: ['create_pool', 'add_liquidity', 'add_liquidity_with_limits', 'remove_liquidity', 'remove_liquidity_with_limits', 'sell', 'buy']; Referrals: ['register_code', 'link_code', 'convert', 'claim_rewards', 'set_reward_percentage']; Liquidation: ['liquidate', 'set_borrowing_contract']; HSM: ['add_collateral_asset', 'remove_collateral_asset', 'update_collateral_asset', 'sell', 'buy', 'execute_arbitrage', 'set_flash_minter']; Signet: ['initialize', 'update_deposit', 'withdraw_funds', 'sign', 'sign_bidirectional', 'respond', 'respond_error', 'respond_bidirectional']; EthDispenser: ['request_fund', 'pause', 'unpause', 'set_faucet_balance']; Tokens: ['transfer', 'transfer_all', 'transfer_keep_alive', 'force_transfer', 'set_balance']; Currencies: ['transfer', 'transfer_native_currency', 'update_balance']; Vesting: ['claim', 'vested_transfer', 'update_vesting_schedules', 'claim_for']; EVM: ['withdraw', 'call', 'create', 'create2']; Ethereum: ['transact']; EVMAccounts: ['bind_evm_address', 'add_contract_deployer', 'remove_contract_deployer', 'renounce_contract_deployer', 'approve_contract', 'disapprove_contract', 'claim_account']; XYKLiquidityMining: ['create_global_farm', 'update_global_farm', 'terminate_global_farm', 'create_yield_farm', 'update_yield_farm', 'stop_yield_farm', 'resume_yield_farm', 'terminate_yield_farm', 'deposit_shares', 'join_farms', 'add_liquidity_and_join_farms', 'redeposit_shares', 'claim_rewards', 'withdraw_shares', 'exit_farms']; DCA: ['schedule', 'terminate', 'unlock_reserves']; Scheduler: ['schedule', 'cancel', 'schedule_named', 'cancel_named', 'schedule_after', 'schedule_named_after', 'set_retry', 'set_retry_named', 'cancel_retry', 'cancel_retry_named']; ParachainSystem: ['set_validation_data', 'sudo_send_upward_message']; 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']; MultiBlockMigrations: ['force_set_cursor', 'force_set_active_cursor', 'force_onboard_mbms', 'clear_historic']; OrmlXcm: ['send_as_sovereign']; XTokens: ['transfer', 'transfer_multiasset', 'transfer_with_fee', 'transfer_multiasset_with_fee', 'transfer_multicurrencies', 'transfer_multiassets']; 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']; EmaOracle: ['add_oracle', 'remove_oracle', 'update_bifrost_oracle']; }; events: { System: ['ExtrinsicSuccess', 'ExtrinsicFailed', 'CodeUpdated', 'NewAccount', 'KilledAccount', 'Remarked', 'UpgradeAuthorized', 'RejectedInvalidAuthorizedUpgrade']; Balances: ['Endowed', 'DustLost', 'Transfer', 'BalanceSet', 'Reserved', 'Unreserved', 'ReserveRepatriated', 'Deposit', 'Withdraw', 'Slashed', 'Minted', 'Burned', 'Suspended', 'Restored', 'Upgraded', 'Issued', 'Rescinded', 'Locked', 'Unlocked', 'Frozen', 'Thawed', 'TotalIssuanceForced']; TransactionPayment: ['TransactionFeePaid']; MultiTransactionPayment: ['CurrencySet', 'CurrencyAdded', 'CurrencyRemoved', 'FeeWithdrawn']; Treasury: ['Spending', 'Awarded', 'Burnt', 'Rollover', 'Deposit', 'SpendApproved', 'UpdatedInactive', 'AssetSpendApproved', 'AssetSpendVoided', 'Paid', 'PaymentFailed', 'SpendProcessed']; Utility: ['BatchInterrupted', 'BatchCompleted', 'BatchCompletedWithErrors', 'ItemCompleted', 'ItemFailed', 'DispatchedAs', 'IfElseMainSuccess', 'IfElseFallbackCalled']; Preimage: ['Noted', 'Requested', 'Cleared']; Identity: ['IdentitySet', 'IdentityCleared', 'IdentityKilled', 'JudgementRequested', 'JudgementUnrequested', 'JudgementGiven', 'RegistrarAdded', 'SubIdentityAdded', 'SubIdentitiesSet', 'SubIdentityRenamed', 'SubIdentityRemoved', 'SubIdentityRevoked', 'AuthorityAdded', 'AuthorityRemoved', 'UsernameSet', 'UsernameQueued', 'PreapprovalExpired', 'PrimaryUsernameSet', 'DanglingUsernameRemoved', 'UsernameUnbound', 'UsernameRemoved', 'UsernameKilled']; Democracy: ['Proposed', 'Tabled', 'ExternalTabled', 'Started', 'Passed', 'NotPassed', 'Cancelled', 'Delegated', 'Undelegated', 'Vetoed', 'Blacklisted', 'Voted', 'Seconded', 'ProposalCanceled', 'MetadataSet', 'MetadataCleared', 'MetadataTransferred']; TechnicalCommittee: ['Proposed', 'Voted', 'Approved', 'Disapproved', 'Executed', 'MemberExecuted', 'Closed', 'Killed', 'ProposalCostBurned', 'ProposalCostReleased']; Proxy: ['ProxyExecuted', 'PureCreated', 'Announced', 'ProxyAdded', 'ProxyRemoved', 'DepositPoked']; Multisig: ['NewMultisig', 'MultisigApproval', 'MultisigExecuted', 'MultisigCancelled', 'DepositPoked']; Uniques: ['Created', 'ForceCreated', 'Destroyed', 'Issued', 'Transferred', 'Burned', 'Frozen', 'Thawed', 'CollectionFrozen', 'CollectionThawed', 'OwnerChanged', 'TeamChanged', 'ApprovedTransfer', 'ApprovalCancelled', 'ItemStatusChanged', 'CollectionMetadataSet', 'CollectionMetadataCleared', 'MetadataSet', 'MetadataCleared', 'Redeposited', 'AttributeSet', 'AttributeCleared', 'OwnershipAcceptanceChanged', 'CollectionMaxSupplySet', 'ItemPriceSet', 'ItemPriceRemoved', 'ItemBought']; StateTrieMigration: ['Migrated', 'Slashed', 'AutoMigrationFinished', 'Halted']; ConvictionVoting: ['Delegated', 'Undelegated', 'Voted', 'VoteRemoved', 'VoteUnlocked']; Referenda: ['Submitted', 'DecisionDepositPlaced', 'DecisionDepositRefunded', 'DepositSlashed', 'DecisionStarted', 'ConfirmStarted', 'ConfirmAborted', 'Confirmed', 'Approved', 'Rejected', 'TimedOut', 'Cancelled', 'Killed', 'SubmissionDepositRefunded', 'MetadataSet', 'MetadataCleared']; Whitelist: ['CallWhitelisted', 'WhitelistedCallRemoved', 'WhitelistedCallDispatched']; Dispatcher: ['TreasuryManagerCallDispatched', 'AaveManagerCallDispatched']; AssetRegistry: ['ExistentialDepositPaid', 'Registered', 'Updated', 'LocationSet', 'AssetBanned', 'AssetUnbanned']; Claims: ['Claim']; CollatorRewards: ['CollatorRewarded']; Omnipool: ['TokenAdded', 'TokenRemoved', 'LiquidityAdded', 'LiquidityRemoved', 'ProtocolLiquidityRemoved', 'SellExecuted', 'BuyExecuted', 'PositionCreated', 'PositionDestroyed', 'PositionUpdated', 'TradableStateUpdated', 'AssetRefunded', 'AssetWeightCapUpdated', 'SlipFeeSet']; TransactionPause: ['TransactionPaused', 'TransactionUnpaused']; Duster: ['Dusted', 'Added', 'Removed']; OmnipoolWarehouseLM: ['GlobalFarmAccRPZUpdated', 'YieldFarmAccRPVSUpdated', 'AllRewardsDistributed']; OmnipoolLiquidityMining: ['GlobalFarmCreated', 'GlobalFarmUpdated', 'GlobalFarmTerminated', 'YieldFarmCreated', 'YieldFarmUpdated', 'YieldFarmStopped', 'YieldFarmResumed', 'YieldFarmTerminated', 'SharesDeposited', 'SharesRedeposited', 'RewardClaimed', 'SharesWithdrawn', 'DepositDestroyed']; OTC: ['Cancelled', 'Filled', 'PartiallyFilled', 'Placed']; CircuitBreaker: ['TradeVolumeLimitChanged', 'AddLiquidityLimitChanged', 'RemoveLiquidityLimitChanged', 'AssetLockdown', 'AssetLockdownRemoved', 'DepositReleased', 'WithdrawLockdownLifted', 'WithdrawLockdownReset', 'WithdrawLimitConfigUpdated', 'WithdrawLockdownTriggered', 'EgressAccountsAdded', 'EgressAccountsRemoved', 'AssetCategoryUpdated']; Router: ['Executed', 'RouteUpdated']; DynamicFees: ['AssetFeeConfigSet', 'AssetFeeConfigRemoved']; Staking: ['PositionCreated', 'StakeAdded', 'RewardsClaimed', 'Unstaked', 'StakingInitialized', 'AccumulatedRpsUpdated']; Stableswap: ['PoolCreated', 'FeeUpdated', 'LiquidityAdded', 'LiquidityRemoved', 'SellExecuted', 'BuyExecuted', 'TradableStateUpdated', 'AmplificationChanging', 'PoolDestroyed', 'PoolPegSourceUpdated', 'PoolMaxPegUpdateUpdated']; Bonds: ['TokenCreated', 'Issued', 'Redeemed']; OtcSettlements: ['Executed']; LBP: ['PoolCreated', 'PoolUpdated', 'LiquidityAdded', 'LiquidityRemoved', 'SellExecuted', 'BuyExecuted']; XYK: ['LiquidityAdded', 'LiquidityRemoved', 'PoolCreated', 'PoolDestroyed', 'SellExecuted', 'BuyExecuted']; Referrals: ['CodeRegistered', 'CodeLinked', 'Converted', 'Claimed', 'AssetRewardsUpdated', 'LevelUp']; Liquidation: ['Liquidated']; HSM: ['CollateralAdded', 'CollateralRemoved', 'CollateralUpdated', 'ArbitrageExecuted', 'FlashMinterSet']; Signet: ['Initialized', 'DepositUpdated', 'FundsWithdrawn', 'SignatureRequested', 'SignBidirectionalRequested', 'SignatureResponded', 'SignatureError', 'RespondBidirectionalEvent']; EthDispenser: ['Paused', 'Unpaused', 'FundRequested', 'FaucetBalanceUpdated']; Tokens: ['Endowed', 'DustLost', 'Transfer', 'Reserved', 'Unreserved', 'ReserveRepatriated', 'BalanceSet', 'TotalIssuanceSet', 'Withdrawn', 'Slashed', 'Deposited', 'LockSet', 'LockRemoved', 'Locked', 'Unlocked', 'Issued', 'Rescinded']; Currencies: ['Transferred', 'BalanceUpdated', 'Deposited', 'Withdrawn']; Vesting: ['VestingScheduleAdded', 'Claimed', 'VestingSchedulesUpdated']; EVM: ['Log', 'Created', 'CreatedFailed', 'Executed', 'ExecutedFailed']; Ethereum: ['Executed']; EVMAccounts: ['Bound', 'DeployerAdded', 'DeployerRemoved', 'ContractApproved', 'ContractDisapproved', 'AccountClaimed']; XYKLiquidityMining: ['GlobalFarmCreated', 'GlobalFarmUpdated', 'YieldFarmCreated', 'GlobalFarmTerminated', 'SharesDeposited', 'SharesRedeposited', 'RewardClaimed', 'SharesWithdrawn', 'YieldFarmStopped', 'YieldFarmResumed', 'YieldFarmTerminated', 'YieldFarmUpdated', 'DepositDestroyed']; XYKWarehouseLM: ['GlobalFarmAccRPZUpdated', 'YieldFarmAccRPVSUpdated', 'AllRewardsDistributed']; RelayChainInfo: ['CurrentBlockNumbers']; DCA: ['ExecutionStarted', 'Scheduled', 'ExecutionPlanned', 'TradeExecuted', 'TradeFailed', 'Terminated', 'Completed', 'RandomnessGenerationFailed', 'ReserveUnlocked']; Scheduler: ['Scheduled', 'Canceled', 'Dispatched', 'RetrySet', 'RetryCancelled', 'CallUnavailable', 'PeriodicFailed', 'RetryFailed', 'PermanentlyOverweight', 'AgendaIncomplete']; ParachainSystem: ['ValidationFunctionStored', 'ValidationFunctionApplied', 'ValidationFunctionDiscarded', 'DownwardMessagesReceived', 'DownwardMessagesProcessed', 'UpwardMessageSent']; 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']; XcmpQueue: ['XcmpMessageSent']; MessageQueue: ['ProcessingFailed', 'Processed', 'OverweightEnqueued', 'PageReaped']; MultiBlockMigrations: ['UpgradeStarted', 'UpgradeCompleted', 'UpgradeFailed', 'MigrationSkipped', 'MigrationAdvanced', 'MigrationCompleted', 'MigrationFailed', 'HistoricCleared']; OrmlXcm: ['Sent']; XTokens: ['TransferredAssets']; UnknownTokens: ['Deposited', 'Withdrawn']; CollatorSelection: ['NewInvulnerables', 'InvulnerableAdded', 'InvulnerableRemoved', 'NewDesiredCandidates', 'NewCandidacyBond', 'CandidateAdded', 'CandidateBondUpdated', 'CandidateRemoved', 'CandidateReplaced', 'InvalidInvulnerableSkipped']; Session: ['NewSession', 'ValidatorDisabled', 'ValidatorReenabled']; EmaOracle: ['AddedToWhitelist', 'RemovedFromWhitelist', 'OracleUpdated']; Broadcast: ['Swapped3']; }; errors: { System: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered', 'MultiBlockMigrationsOngoing', 'NothingAuthorized', 'Unauthorized']; Balances: ['VestingBalance', 'LiquidityRestrictions', 'InsufficientBalance', 'ExistentialDeposit', 'Expendability', 'ExistingVestingSchedule', 'DeadAccount', 'TooManyReserves', 'TooManyHolds', 'TooManyFreezes', 'IssuanceDeactivated', 'DeltaZero']; MultiTransactionPayment: ['UnsupportedCurrency', 'ZeroBalance', 'AlreadyAccepted', 'CoreAssetNotAllowed', 'ZeroPrice', 'FallbackPriceNotFound', 'Overflow', 'EvmAccountNotAllowed', 'EvmPermitExpired', 'EvmPermitInvalid', 'EvmPermitCallExecutionError', 'EvmPermitRunnerError', 'EvmPermitNonceInvariantViolated']; Treasury: ['InvalidIndex', 'TooManyApprovals', 'InsufficientPermission', 'ProposalNotApproved', 'FailedToConvertBalance', 'SpendExpired', 'EarlyPayout', 'AlreadyAttempted', 'PayoutError', 'NotAttempted', 'Inconclusive']; Utility: ['TooManyCalls']; Preimage: ['TooBig', 'AlreadyNoted', 'NotAuthorized', 'NotNoted', 'Requested', 'NotRequested', 'TooMany', 'TooFew']; Identity: ['TooManySubAccounts', 'NotFound', 'NotNamed', 'EmptyIndex', 'FeeChanged', 'NoIdentity', 'StickyJudgement', 'JudgementGiven', 'InvalidJudgement', 'InvalidIndex', 'InvalidTarget', 'TooManyRegistrars', 'AlreadyClaimed', 'NotSub', 'NotOwned', 'JudgementForDifferentIdentity', 'JudgementPaymentFailed', 'InvalidSuffix', 'NotUsernameAuthority', 'NoAllocation', 'InvalidSignature', 'RequiresSignature', 'InvalidUsername', 'UsernameTaken', 'NoUsername', 'NotExpired', 'TooEarly', 'NotUnbinding', 'AlreadyUnbinding', 'InsufficientPrivileges']; Democracy: ['ValueLow', 'ProposalMissing', 'AlreadyCanceled', 'DuplicateProposal', 'ProposalBlacklisted', 'NotSimpleMajority', 'InvalidHash', 'NoProposal', 'AlreadyVetoed', 'ReferendumInvalid', 'NoneWaiting', 'NotVoter', 'NoPermission', 'AlreadyDelegating', 'InsufficientFunds', 'NotDelegating', 'VotesExist', 'InstantNotAllowed', 'Nonsense', 'WrongUpperBound', 'MaxVotesReached', 'TooMany', 'VotingPeriodLow', 'PreimageNotExist']; TechnicalCommittee: ['NotMember', 'DuplicateProposal', 'ProposalMissing', 'WrongIndex', 'DuplicateVote', 'AlreadyInitialized', 'TooEarly', 'TooManyProposals', 'WrongProposalWeight', 'WrongProposalLength', 'PrimeAccountNotMember', 'ProposalActive']; Proxy: ['TooMany', 'NotFound', 'NotProxy', 'Unproxyable', 'Duplicate', 'NoPermission', 'Unannounced', 'NoSelfProxy']; Multisig: ['MinimumThreshold', 'AlreadyApproved', 'NoApprovalsNeeded', 'TooFewSignatories', 'TooManySignatories', 'SignatoriesOutOfOrder', 'SenderInSignatories', 'NotFound', 'NotOwner', 'NoTimepoint', 'WrongTimepoint', 'UnexpectedTimepoint', 'MaxWeightTooLow', 'AlreadyStored']; Uniques: ['NoPermission', 'UnknownCollection', 'AlreadyExists', 'WrongOwner', 'BadWitness', 'InUse', 'Frozen', 'WrongDelegate', 'NoDelegate', 'Unapproved', 'Unaccepted', 'Locked', 'MaxSupplyReached', 'MaxSupplyAlreadySet', 'MaxSupplyTooSmall', 'UnknownItem', 'NotForSale', 'BidTooLow']; StateTrieMigration: ['MaxSignedLimits', 'KeyTooLong', 'NotEnoughFunds', 'BadWitness', 'SignedMigrationNotAllowed', 'BadChildRoot']; ConvictionVoting: ['NotOngoing', 'NotVoter', 'NoPermission', 'NoPermissionYet', 'AlreadyDelegating', 'AlreadyVoting', 'InsufficientFunds', 'NotDelegating', 'Nonsense', 'MaxVotesReached', 'ClassNeeded', 'BadClass']; Referenda: ['NotOngoing', 'HasDeposit', 'BadTrack', 'Full', 'QueueEmpty', 'BadReferendum', 'NothingToDo', 'NoTrack', 'Unfinished', 'NoPermission', 'NoDeposit', 'BadStatus', 'PreimageNotExist', 'PreimageStoredWithDifferentLength']; Whitelist: ['UnavailablePreImage', 'UndecodableCall', 'InvalidCallWeightWitness', 'CallIsNotWhitelisted', 'CallAlreadyWhitelisted']; Dispatcher: ['EvmCallFailed', 'NotEvmCall', 'EvmOutOfGas', 'EvmArithmeticOverflowOrUnderflow', 'AaveSupplyCapExceeded', 'AaveBorrowCapExceeded', 'AaveHealthFactorNotBelowThreshold', 'AaveHealthFactorLowerThanLiquidationThreshold', 'CollateralCannotCoverNewBorrow']; AssetRegistry: ['NoIdAvailable', 'AssetNotFound', 'TooShort', 'InvalidSymbol', 'AssetNotRegistered', 'AssetAlreadyRegistered', 'InvalidSharedAssetLen', 'CannotUpdateLocation', 'NotInReservedRange', 'LocationAlreadyRegistered', 'Forbidden', 'InsufficientBalance', 'ForbiddenSufficiencyChange', 'AssetAlreadyBanned', 'AssetNotBanned']; Claims: ['InvalidEthereumSignature', 'NoClaimOrAlreadyClaimed', 'BalanceOverflow']; Omnipool: ['InsufficientBalance', 'AssetAlreadyAdded', 'AssetNotFound', 'MissingBalance', 'InvalidInitialAssetPrice', 'BuyLimitNotReached', 'SellLimitExceeded', 'PositionNotFound', 'InsufficientShares', 'NotAllowed', 'Forbidden', 'AssetWeightCapExceeded', 'AssetNotRegistered', 'InsufficientLiquidity', 'InsufficientTradingAmount', 'SameAssetTradeNotAllowed', 'HubAssetUpdateError', 'InvalidSharesAmount', 'InvalidHubAssetTradableState', 'AssetRefundNotAllowed', 'MaxOutRatioExceeded', 'MaxInRatioExceeded', 'PriceDifferenceTooHigh', 'InvalidOraclePrice', 'InvalidWithdrawalFee', 'FeeOverdraft', 'SharesRemaining', 'AssetNotFrozen', 'ZeroAmountOut', 'ExistentialDepositNotAvailable', 'SlippageLimit', 'ProtocolFeeNotConsumed', 'MaxSlipFeeTooHigh']; TransactionPause: ['CannotPause', 'InvalidCharacter', 'NameTooLong']; Duster: ['AccountWhitelisted', 'AccountNotWhitelisted', 'ZeroBalance', 'NonZeroBalance', 'BalanceSufficient', 'ReserveAccountNotSet']; OmnipoolWarehouseLM: ['GlobalFarmNotFound', 'YieldFarmNotFound', 'DoubleClaimInPeriod', 'LiquidityMiningCanceled', 'LiquidityMiningIsActive', 'LiquidityMiningIsNotStopped', 'Forbidden', 'InvalidMultiplier', 'YieldFarmAlreadyExists', 'InvalidInitialRewardPercentage', 'GlobalFarmIsNotEmpty', 'MissingIncentivizedAsset', 'InsufficientRewardCurrencyBalance', 'InvalidBlocksPerPeriod', 'InvalidYieldPerPeriod', 'InvalidTotalRewards', 'InvalidPlannedYieldingPeriods', 'MaxEntriesPerDeposit', 'DoubleLock', 'YieldFarmEntryNotFound', 'GlobalFarmIsFull', 'InvalidMinDeposit', 'InvalidPriceAdjustment', 'ErrorGetAccountId', 'IncorrectValuedShares', 'RewardCurrencyNotRegistered', 'IncentivizedAssetNotRegistered', 'AmmPoolIdMismatch', 'InconsistentState']; OmnipoolLiquidityMining: ['AssetNotFound', 'Forbidden', 'ZeroClaimedRewards', 'InconsistentState', 'OracleNotAvailable', 'PriceAdjustmentNotAvailable', 'NoFarmEntriesSpecified', 'NoAssetsSpecified', 'PositionIdMismatch']; OTC: ['AssetNotRegistered', 'OrderNotFound', 'OrderIdOutOfBound', 'OrderNotPartiallyFillable', 'OrderAmountTooSmall', 'MathError', 'Forbidden', 'InsufficientReservedAmount']; CircuitBreaker: ['InvalidLimitValue', 'LiquidityLimitNotStoredForAsset', 'TokenOutflowLimitReached', 'TokenInfluxLimitReached', 'MaxLiquidityLimitPerBlockReached', 'NotAllowed', 'AssetInLockdown', 'AssetNotInLockdown', 'InvalidAmount', 'DepositLimitExceededForWhitelistedAccount', 'WithdrawLockdownActive', 'GlobalWithdrawLimitExceeded', 'FailedToConvertAsset']; Router: ['TradingLimitReached', 'MaxTradesExceeded', 'PoolNotSupported', 'InsufficientBalance', 'RouteCalculationFailed', 'InvalidRoute', 'RouteUpdateIsNotSuccessful', 'RouteHasNoOracle', 'InvalidRouteExecution', 'NotAllowed']; DynamicFees: ['InvalidFeeParameters']; Staking: ['InsufficientBalance', 'InsufficientStake', 'PositionNotFound', 'MaxVotesReached', 'NotInitialized', 'AlreadyInitialized', 'Arithmetic', 'MissingPotBalance', 'PositionAlreadyExists', 'Forbidden', 'ExistingVotes', 'ExistingProcessedVotes', 'InconsistentState']; Stableswap: ['IncorrectAssets', 'MaxAssetsExceeded', 'PoolNotFound', 'PoolExists', 'AssetNotInPool', 'ShareAssetNotRegistered', 'ShareAssetInPoolAssets', 'AssetNotRegistered', 'InvalidAssetAmount', 'InsufficientBalance', 'InsufficientShares', 'InsufficientLiquidity', 'InsufficientLiquidityRemaining', 'InsufficientTradingAmount', 'BuyLimitNotReached', 'SellLimitExceeded', 'InvalidInitialLiquidity', 'InvalidAmplification', 'InsufficientShareBalance', 'NotAllowed', 'PastBlock', 'SameAmplification', 'SlippageLimit', 'UnknownDecimals', 'IncorrectInitialPegs', 'MissingTargetPegOracle', 'IncorrectAssetDecimals', 'NoPegSource', 'ZeroAmountOut', 'ZeroAmountIn']; Bonds: ['NotRegistered', 'NotMature', 'InvalidMaturity', 'DisallowedAsset', 'AssetNotFound', 'InvalidBondName', 'FailToParseName']; OtcSettlements: ['OrderNotFound', 'NotPartiallyFillable', 'InvalidRoute', 'BalanceInconsistency', 'TradeAmountTooHigh', 'TradeAmountTooLow', 'PriceNotAvailable']; LBP: ['CannotCreatePoolWithSameAssets', 'NotOwner', 'SaleStarted', 'SaleNotEnded', 'SaleIsNotRunning', 'MaxSaleDurationExceeded', 'CannotAddZeroLiquidity', 'InsufficientAssetBalance', 'PoolNotFound', 'PoolAlreadyExists', 'InvalidBlockRange', 'WeightCalculationError', 'InvalidWeight', 'ZeroAmount', 'MaxInRatioExceeded', 'MaxOutRatioExceeded', 'FeeAmountInvalid', 'TradingLimitReached', 'Overflow', 'NothingToUpdate', 'InsufficientLiquidity', 'InsufficientTradingAmount', 'FeeCollectorWithAssetAlreadyUsed']; XYK: ['CannotCreatePoolWithSameAssets', 'InsufficientLiquidity', 'InsufficientTradingAmount', 'ZeroLiquidity', 'InvalidMintedLiquidity', 'InvalidLiquidityAmount', 'AssetAmountExceededLimit', 'AssetAmountNotReachedLimit', 'InsufficientAssetBalance', 'InsufficientPoolAssetBalance', 'InsufficientNativeCurrencyBalance', 'TokenPoolNotFound', 'TokenPoolAlreadyExists', 'AddAssetAmountInvalid', 'RemoveAssetAmountInvalid', 'SellAssetAmountInvalid', 'BuyAssetAmountInvalid', 'FeeAmountInvalid', 'MaxOutRatioExceeded', 'MaxInRatioExceeded', 'Overflow', 'CannotCreatePool', 'SlippageLimit']; Referrals: ['TooLong', 'TooShort', 'InvalidCharacter', 'AlreadyExists', 'InvalidCode', 'AlreadyLinked', 'ZeroAmount', 'LinkNotAllowed', 'IncorrectRewardCalculation', 'IncorrectRewardPercentage', 'AlreadyRegistered', 'PriceNotFound', 'ConversionMinTradingAmountNotReached', 'ConversionZeroAmountReceived']; Liquidation: ['AssetConversionFailed', 'LiquidationCallFailed', 'InvalidRoute', 'NotProfitable', 'FlashMinterNotSet', 'InvalidLiquidationData']; HSM: ['AssetNotApproved', 'AssetAlreadyApproved', 'PoolAlreadyHasCollateral', 'InvalidAssetPair', 'MaxBuyPriceExceeded', 'MaxBuyBackExceeded', 'MaxHoldingExceeded', 'SlippageLimitExceeded', 'InvalidEVMInteraction', 'DecimalRetrievalFailed', 'NoArbitrageOpportunity', 'AssetNotFound', 'InvalidPoolState', 'CollateralNotEmpty', 'AssetNotInPool', 'HollarNotInPool', 'InsufficientCollateralBalance', 'HollarContractAddressNotFound', 'MaxNumberOfCollateralsReached', 'FlashMinterNotSet', 'InvalidArbitrageData']; Signet: ['AlreadyInitialized', 'NotInitialized', 'Unauthorized', 'InsufficientFunds', 'InvalidTransaction', 'InvalidInputLength', 'ChainIdTooLong', 'DataTooLong', 'InvalidAddress', 'InvalidGasPrice', 'MaxDepositExceeded']; EthDispenser: ['DuplicateRequest', 'Serialization', 'InvalidOutput', 'InvalidRequestId', 'Paused', 'AmountTooSmall', 'AmountTooLarge', 'InvalidAddress', 'FaucetBalanceBelowThreshold', 'NotEnoughFeeFunds', 'NotEnoughFaucetFunds']; Tokens: ['BalanceTooLow', 'AmountIntoBalanceFailed', 'LiquidityRestrictions', 'MaxLocksExceeded', 'KeepAlive', 'ExistentialDeposit', 'DeadAccount', 'TooManyReserves']; Currencies: ['AmountIntoBalanceFailed', 'BalanceTooLow', 'DepositFailed', 'NotSupported']; Vesting: ['ZeroVestingPeriod', 'ZeroVestingPeriodCount', 'InsufficientBalanceToLock', 'TooManyVestingSchedules', 'AmountLow', 'MaxVestingSchedulesExceeded']; EVM: ['BalanceLow', 'FeeOverflow', 'PaymentOverflow', 'WithdrawFailed', 'GasPriceTooLow', 'InvalidNonce', 'GasLimitTooLow', 'GasLimitTooHigh', 'InvalidChainId', 'InvalidSignature', 'Reentrancy', 'TransactionMustComeFromEOA', 'Undefined', 'CreateOriginNotAllowed']; Ethereum: ['InvalidSignature', 'PreLogExists']; EVMAccounts: ['TruncatedAccountAlreadyUsed', 'AddressAlreadyBound', 'BoundAddressCannotBeUsed', 'AddressNotWhitelisted', 'InvalidSignature', 'AccountAlreadyExists', 'InsufficientAssetBalance']; XYKLiquidityMining: ['CantFindDepositOwner', 'InsufficientXykSharesBalance', 'XykPoolDoesntExist', 'NotDepositOwner', 'CantGetXykAssets', 'DepositDataNotFound', 'ZeroClaimedRewards', 'AssetNotInAssetPair', 'InvalidAssetPair', 'AssetNotRegistered', 'FailToGetPotId', 'NoFarmsSpecified', 'FailedToValueShares']; XYKWarehouseLM: ['GlobalFarmNotFound', 'YieldFarmNotFound', 'DoubleClaimInPeriod', 'LiquidityMiningCanceled', 'LiquidityMiningIsActive', 'LiquidityMiningIsNotStopped', 'Forbidden', 'InvalidMultiplier', 'YieldFarmAlreadyExists', 'InvalidInitialRewardPercentage', 'GlobalFarmIsNotEmpty', 'MissingIncentivizedAsset', 'InsufficientRewardCurrencyBalance', 'InvalidBlocksPerPeriod', 'InvalidYieldPerPeriod', 'InvalidTotalRewards', 'InvalidPlannedYieldingPeriods', 'MaxEntriesPerDeposit', 'DoubleLock', 'YieldFarmEntryNotFound', 'GlobalFarmIsFull', 'InvalidMinDeposit', 'InvalidPriceAdjustment', 'ErrorGetAccountId', 'IncorrectValuedShares', 'RewardCurrencyNotRegistered', 'IncentivizedAssetNotRegistered', 'AmmPoolIdMismatch', 'InconsistentState']; DCA: ['ScheduleNotFound', 'MinTradeAmountNotReached', 'Forbidden', 'BlockNumberIsNotInFuture', 'PriceUnstable', 'Bumped', 'CalculatingPriceError', 'TotalAmountIsSmallerThanMinBudget', 'BudgetTooLow', 'NoFreeBlockFound', 'ManuallyTerminated', 'MaxRetryReached', 'TradeLimitReached', 'SlippageLimitReached', 'NoParentHashFound', 'InvalidState', 'PeriodTooShort', 'StabilityThresholdTooHigh', 'HasActiveSchedules', 'NoReservesLocked']; Scheduler: ['FailedToSchedule', 'NotFound', 'TargetBlockNumberInPast', 'RescheduleNoChange', 'Named']; ParachainSystem: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled']; 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']; XcmpQueue: ['BadQueueConfig', 'AlreadySuspended', 'AlreadyResumed', 'TooManyActiveOutboundChannels', 'TooBig']; MessageQueue: ['NotReapable', 'NoPage', 'NoMessage', 'AlreadyProcessed', 'Queued', 'InsufficientWeight', 'TemporarilyUnprocessable', 'QueuePaused', 'RecursiveDisallowed']; MultiBlockMigrations: ['Ongoing']; OrmlXcm: ['Unreachable', 'SendFailure', 'BadVersion']; XTokens: ['AssetHasNoReserve', 'NotCrossChainTransfer', 'InvalidDest', 'NotCrossChainTransferableCurrency', 'UnweighableMessage', 'XcmExecutionFailed', 'CannotReanchor', 'InvalidAncestry', 'InvalidAsset', 'DestinationNotInvertible', 'BadVersion', 'DistinctReserveForAssetAndFee', 'ZeroFee', 'ZeroAmount', 'TooManyAssetsBeingSent', 'AssetIndexNonExistent', 'FeeNotEnough', 'NotSupportedLocation', 'MinXcmFeeNotDefined', 'RateLimited']; UnknownTokens: ['BalanceTooLow', 'BalanceOverflow', 'UnhandledAsset']; CollatorSelection: ['TooManyCandidates', 'TooFewEligibleCollators', 'AlreadyCandidate', 'NotCandidate', 'TooManyInvulnerables', 'AlreadyInvulnerable', 'NotInvulnerable', 'NoAssociatedValidatorId', 'ValidatorNotRegistered', 'InsertToCandidateListFailed', 'RemoveFromCandidateListFailed', 'DepositTooLow', 'UpdateCandidateListFailed', 'InsufficientBond', 'TargetIsNotCandidate', 'IdenticalDeposit', 'InvalidUnreserve']; Session: ['InvalidProof', 'NoAssociatedValidatorId', 'DuplicatedKey', 'NoKeys', 'NoAccount']; EmaOracle: ['TooManyUniqueEntries', 'OnTradeValueZero', 'OracleNotFound', 'AssetNotFound', 'PriceOutsideAllowedRange']; Broadcast: ['ExecutionCallStackOverflow', 'ExecutionCallStackUnderflow']; }; constants: { System: ['BlockWeights', 'BlockLength', 'BlockHashCount', 'DbWeight', 'Version', 'SS58Prefix']; Timestamp: ['MinimumPeriod']; Balances: ['ExistentialDeposit', 'MaxLocks', 'MaxReserves', 'MaxFreezes']; TransactionPayment: ['OperationalFeeMultiplier']; MultiTransactionPayment: ['NativeAssetId', 'PolkadotNativeAssetId', 'EvmAssetId']; Treasury: ['SpendPeriod', 'Burn', 'PalletId', 'MaxApprovals', 'PayoutPeriod', 'pot_account']; Utility: ['batched_calls_limit']; Identity: ['BasicDeposit', 'ByteDeposit', 'UsernameDeposit', 'SubAccountDeposit', 'MaxSubAccounts', 'MaxRegistrars', 'PendingUsernameExpiration', 'UsernameGracePeriod', 'MaxSuffixLength', 'MaxUsernameLength']; Democracy: ['EnactmentPeriod', 'LaunchPeriod', 'VotingPeriod', 'VoteLockingPeriod', 'MinimumDeposit', 'InstantAllowed', 'FastTrackVotingPeriod', 'CooloffPeriod', 'MaxVotes', 'MaxProposals', 'MaxDeposits', 'MaxBlacklisted']; TechnicalCommittee: ['MaxProposalWeight']; Proxy: ['ProxyDepositBase', 'ProxyDepositFactor', 'MaxProxies', 'MaxPending', 'AnnouncementDepositBase', 'AnnouncementDepositFactor']; Multisig: ['DepositBase', 'DepositFactor', 'MaxSignatories']; Uniques: ['CollectionDeposit', 'ItemDeposit', 'MetadataDepositBase', 'AttributeDepositBase', 'DepositPerByte', 'StringLimit', 'KeyLimit', 'ValueLimit']; StateTrieMigration: ['MaxKeyLen']; ConvictionVoting: ['MaxVotes', 'VoteLockingPeriod']; Referenda: ['SubmissionDeposit', 'MaxQueued', 'UndecidingTimeout', 'AlarmInterval', 'Tracks']; AssetRegistry: ['SequentialIdStartAt', 'StringLimit', 'MinStringLimit', 'RegExternalWeightMultiplier']; CollatorRewards: ['RewardPerCollator', 'RewardCurrencyId', 'RewardsBag']; Omnipool: ['HdxAssetId', 'HubAssetId', 'MinWithdrawalFee', 'MinimumTradingLimit', 'MinimumPoolLiquidity', 'MaxInRatio', 'MaxOutRatio', 'NFTCollectionId', 'BurnProtocolFee', 'HubDestination']; Duster: ['TreasuryAccountId']; OmnipoolWarehouseLM: ['PalletId', 'TreasuryAccountId', 'MinTotalFarmRewards', 'MinPlannedYieldingPeriods', 'MaxFarmEntriesPerDeposit', 'MaxYieldFarmsPerGlobalFarm']; OmnipoolLiquidityMining: ['NFTCollectionId', 'OracleSource', 'OraclePeriod']; OTC: ['ExistentialDepositMultiplier', 'Fee', 'FeeReceiver']; CircuitBreaker: ['DefaultMaxNetTradeVolumeLimitPerBlock', 'DefaultMaxAddLiquidityLimitPerBlock', 'DefaultMaxRemoveLiquidityLimitPerBlock']; Router: ['NativeAssetId', 'OraclePeriod']; DynamicFees: ['AssetFeeParameters', 'ProtocolFeeParameters']; Staking: ['PeriodLength', 'PalletId', 'NativeAssetId', 'MinStake', 'TimePointsWeight', 'ActionPointsWeight', 'TimePointsPerPeriod', 'UnclaimablePeriods', 'CurrentStakeWeight', 'MaxVotes', 'NFTCollectionId']; Stableswap: ['MinPoolLiquidity', 'MinTradingLimit', 'AmplificationRange']; Bonds: ['PalletId', 'ProtocolFee', 'FeeReceiver']; OtcSettlements: ['ProfitReceiver', 'MinProfitPercentage', 'PricePrecision', 'MinTradingLimit', 'MaxIterations']; LBP: ['MinTradingLimit', 'MinPoolLiquidity', 'MaxInRatio', 'MaxOutRatio', 'repay_fee']; XYK: ['NativeAssetId', 'GetExchangeFee', 'MinTradingLimit', 'MinPoolLiquidity', 'MaxInRatio', 'MaxOutRatio', 'OracleSource']; Referrals: ['RewardAsset', 'PalletId', 'RegistrationFee', 'CodeLength', 'MinCodeLength', 'SeedNativeAmount']; Liquidation: ['GasLimit', 'ProfitReceiver', 'HollarId']; HSM: ['HollarId', 'PalletId', 'MinArbitrageAmount', 'FlashLoanReceiver', 'GasLimit']; Signet: ['PalletId', 'MaxChainIdLength', 'MaxDataLength', 'MaxSignatureDeposit']; EthDispenser: ['MinimumRequestAmount', 'MaxDispenseAmount', 'DispenserFee', 'FeeAsset', 'FaucetAsset', 'FeeDestination', 'FaucetAddress', 'PalletId', 'MinFaucetEthThreshold']; Tokens: ['MaxLocks', 'MaxReserves']; Currencies: ['ReserveAccount', 'GetNativeCurrencyId']; Vesting: ['MinVestedTransfer']; EVMAccounts: ['FeeMultiplier']; DynamicEvmFee: ['WethAssetId']; XYKLiquidityMining: ['NFTCollectionId', 'OracleSource', 'OraclePeriod']; XYKWarehouseLM: ['PalletId', 'TreasuryAccountId', 'MinTotalFarmRewards', 'MinPlannedYieldingPeriods', 'MaxFarmEntriesPerDeposit', 'MaxYieldFarmsPerGlobalFarm']; DCA: ['MaxPriceDifferenceBetweenBlocks', 'MaxConfigurablePriceDifferenceBetweenBlocks', 'MaxSchedulePerBlock', 'MaxNumberOfRetriesOnError', 'MinimalPeriod', 'BumpChance', 'MinimumTradingLimit', 'NativeAssetId', 'PolkadotNativeAssetId', 'MinBudgetInNativeCurrency', 'FeeReceiver', 'NamedReserveId']; Scheduler: ['MaximumWeight', 'MaxScheduledPerBlock']; ParachainSystem: ['SelfParaId']; PolkadotXcm: ['UniversalLocation', 'AdvertisedXcmVersion', 'MaxLockers', 'MaxRemoteLockConsumers']; XcmpQueue: ['MaxInboundSuspended', 'MaxActiveOutboundChannels', 'MaxPageSize']; MessageQueue: ['HeapSize', 'MaxStale', 'ServiceWeight', 'IdleMaxServiceWeight']; MultiBlockMigrations: ['CursorMaxLen', 'IdentifierMaxLen']; XTokens: ['SelfLocation', 'BaseXcmWeight', 'RateLimiterId']; CollatorSelection: ['PotId', 'MaxCandidates', 'MinEligibleCollators', 'MaxInvulnerables', 'KickThreshold', 'pot_account']; Aura: ['SlotDuration']; EmaOracle: ['MaxAllowedPriceDifference', 'MaxUniqueEntries']; }; viewFns: {}; apis: { 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']; AuraApi: ['slot_duration', 'authorities']; CollectCollationInfo: ['collect_collation_info']; CurrenciesApi: ['account', 'accounts', 'free_balance', 'minimum_balance']; AccountNonceApi: ['account_nonce']; TransactionPaymentApi: ['query_info', 'query_fee_details', 'query_weight_to_fee', 'query_length_to_fee']; EthereumRuntimeRPCApi: ['chain_id', 'account_basic', 'gas_price', 'account_code_at', 'author', 'storage_at', 'call', 'create', 'current_block', 'current_receipts', 'current_transaction_statuses', 'current_all', 'extrinsic_filter', 'elasticity', 'gas_limit_multiplier_support', 'pending_block', 'initialize_pending_block']; ConvertTransactionRuntimeApi: ['convert_transaction']; EvmAccountsApi: ['evm_address', 'bound_account_id', 'account_id']; DusterApi: ['is_whitelisted']; Erc20MappingApi: ['asset_address', 'address_to_asset']; XcmPaymentApi: ['query_acceptable_payment_assets', 'query_xcm_weight', 'query_weight_to_asset_fee', 'query_delivery_fees']; AuraUnincludedSegmentApi: ['can_build_upon']; DryRunApi: ['dry_run_call', 'dry_run_xcm']; LocationToAccountApi: ['convert_location']; ChainlinkAdapterApi: ['encode_oracle_address', 'decode_oracle_address']; AaveTradeExecutor: ['pairs', 'liquidity_depth', 'pool', 'pools']; GenesisBuilder: ['build_state', 'get_preset', 'preset_names']; }; }; export type HydrationNextWhitelistEntry = 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];