diff --git a/CHANGELOG.md b/CHANGELOG.md index 05220dc4be..d9b520d5db 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ Contributed: Changes: +- Expose `@polkadot/api-augment/{kusama, polkadot, substrate}` for specific augmentations (The bare `@polkadot/api-augment` is equivalent to `/substrate`, keeping the existing behavior) - Expose `txHash` on submittable results, e.g. `tx.signAndSend(..., ({ txHash }) => ...)` - Align casing for TS & exposed queries (adjusts for `ALLCAPS` entries) - Split `types-augment` into `registry` & `lookup` variants (better control) diff --git a/package.json b/package.json index 5fdc8d872f..adc68cca2a 100644 --- a/package.json +++ b/package.json @@ -34,7 +34,7 @@ "@babel/core": "^7.16.5", "@babel/register": "^7.16.5", "@babel/runtime": "^7.16.5", - "@polkadot/dev": "^0.64.18", + "@polkadot/dev": "^0.64.19", "@polkadot/ts": "^0.4.22", "@polkadot/typegen": "workspace:packages/typegen", "@types/jest": "^27.0.3", diff --git a/packages/api-augment/src/augment/index.ts b/packages/api-augment/src/base.ts similarity index 62% rename from packages/api-augment/src/augment/index.ts rename to packages/api-augment/src/base.ts index 443ff26779..9272bd2484 100644 --- a/packages/api-augment/src/augment/index.ts +++ b/packages/api-augment/src/base.ts @@ -4,9 +4,3 @@ // for the API, we decorate not only the endpoints, but all types import '@polkadot/rpc-augment'; import '@polkadot/types-augment'; -// the augmentated types (on top of @polkadot/api-base) -import './consts'; -import './errors'; -import './events'; -import './query'; -import './tx'; diff --git a/packages/api-augment/src/bundle.ts b/packages/api-augment/src/bundle.ts index 55d51c5706..df28f2a72e 100644 --- a/packages/api-augment/src/bundle.ts +++ b/packages/api-augment/src/bundle.ts @@ -1,6 +1,6 @@ // Copyright 2017-2021 @polkadot/api-augment authors & contributors // SPDX-License-Identifier: Apache-2.0 -import './augment'; +import './substrate'; export { packageInfo } from './packageInfo'; diff --git a/packages/api-augment/src/kusama/consts.ts b/packages/api-augment/src/kusama/consts.ts new file mode 100644 index 0000000000..7870c828c9 --- /dev/null +++ b/packages/api-augment/src/kusama/consts.ts @@ -0,0 +1,896 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; +import type { Bytes, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { Codec } from '@polkadot/types-codec/types'; +import type { Perbill, Percent, Permill } from '@polkadot/types/interfaces/runtime'; +import type { FrameSupportPalletId, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion } from '@polkadot/types/lookup'; + +declare module '@polkadot/api-base/types/consts' { + export interface AugmentedConsts { + auctions: { + /** + * The number of blocks over which an auction may be retroactively ended. + **/ + endingPeriod: u32 & AugmentedConst; + leasePeriodsPerSlot: u32 & AugmentedConst; + /** + * The length of each sample to take during the ending period. + * + * `EndingPeriod` / `SampleLength` = Total # of Samples + **/ + sampleLength: u32 & AugmentedConst; + slotRangeCount: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + authorship: { + /** + * The number of blocks back we should accept uncles. + * This means that we will deal with uncle-parents that are + * `UncleGenerations + 1` before `now`. + **/ + uncleGenerations: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + babe: { + /** + * The amount of time, in slots, that each epoch should last. + * NOTE: Currently it is not possible to change the epoch duration after + * the chain has started. Attempting to do so will brick block production. + **/ + epochDuration: u64 & AugmentedConst; + /** + * The expected average block time at which BABE should be creating + * blocks. Since BABE is probabilistic it is not trivial to figure out + * what the expected average block time should be based on the slot + * duration and the security parameter `c` (where `1 - c` represents + * the probability of a slot being empty). + **/ + expectedBlockTime: u64 & AugmentedConst; + /** + * Max number of authorities allowed + **/ + maxAuthorities: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + bagsList: { + /** + * The list of thresholds separating the various bags. + * + * Ids are separated into unsorted bags according to their vote weight. This specifies the + * thresholds separating the bags. An id's bag is the largest bag for which the id's weight + * is less than or equal to its upper threshold. + * + * When ids are iterated, higher bags are iterated completely before lower bags. This means + * that iteration is _semi-sorted_: ids of higher weight tend to come before ids of lower + * weight, but peer ids within a particular bag are sorted in insertion order. + * + * # Expressing the constant + * + * This constant must be sorted in strictly increasing order. Duplicate items are not + * permitted. + * + * There is an implied upper limit of `VoteWeight::MAX`; that value does not need to be + * specified within the bag. For any two threshold lists, if one ends with + * `VoteWeight::MAX`, the other one does not, and they are otherwise equal, the two lists + * will behave identically. + * + * # Calculation + * + * It is recommended to generate the set of thresholds in a geometric series, such that + * there exists some constant ratio such that `threshold[k + 1] == (threshold[k] * + * constant_ratio).max(threshold[k] + 1)` for all `k`. + * + * The helpers in the `/utils/frame/generate-bags` module can simplify this calculation. + * + * # Examples + * + * - If `BagThresholds::get().is_empty()`, then all ids are put into the same bag, and + * iteration is strictly in insertion order. + * - If `BagThresholds::get().len() == 64`, and the thresholds are determined according to + * the procedure given above, then the constant ratio is equal to 2. + * - If `BagThresholds::get().len() == 200`, and the thresholds are determined according to + * the procedure given above, then the constant ratio is approximately equal to 1.248. + * - If the threshold list begins `[1, 2, 3, ...]`, then an id with weight 0 or 1 will fall + * into bag 0, an id with weight 2 will fall into bag 1, etc. + * + * # Migration + * + * In the event that this list ever changes, a copy of the old bags list must be retained. + * With that `List::migrate` can be called, which will perform the appropriate migration. + **/ + bagThresholds: Vec & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + balances: { + /** + * The minimum amount required to keep an account open. + **/ + existentialDeposit: u128 & AugmentedConst; + /** + * The maximum number of locks that should exist on an account. + * Not strictly enforced, but used for weight estimation. + **/ + maxLocks: u32 & AugmentedConst; + /** + * The maximum number of named reserves that can exist on an account. + **/ + maxReserves: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + bounties: { + /** + * Percentage of the curator fee that will be reserved upfront as deposit for bounty + * curator. + **/ + bountyCuratorDeposit: Permill & AugmentedConst; + /** + * The amount held on deposit for placing a bounty proposal. + **/ + bountyDepositBase: u128 & AugmentedConst; + /** + * The delay period for which a bounty beneficiary need to wait before claim the payout. + **/ + bountyDepositPayoutDelay: u32 & AugmentedConst; + /** + * Bounty duration in blocks. + **/ + bountyUpdatePeriod: u32 & AugmentedConst; + /** + * Minimum value for a bounty. + **/ + bountyValueMinimum: u128 & AugmentedConst; + /** + * The amount held on deposit per byte within the tip report reason or bounty description. + **/ + dataDepositPerByte: u128 & AugmentedConst; + /** + * Maximum acceptable reason length. + * + * Benchmarks depend on this value, be sure to update weights file when changing this value + **/ + maximumReasonLength: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + claims: { + prefix: Bytes & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + crowdloan: { + /** + * The minimum amount that may be contributed into a crowdloan. Should almost certainly be at + * least `ExistentialDeposit`. + **/ + minContribution: u128 & AugmentedConst; + /** + * `PalletId` for the crowdloan pallet. An appropriate value could be `PalletId(*b"py/cfund")` + **/ + palletId: FrameSupportPalletId & AugmentedConst; + /** + * Max number of storage keys to remove per extrinsic call. + **/ + removeKeysLimit: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + democracy: { + /** + * Period in blocks where an external proposal may not be re-submitted after being vetoed. + **/ + cooloffPeriod: u32 & AugmentedConst; + /** + * The period between a proposal being approved and enacted. + * + * It should generally be a little more than the unstake period to ensure that + * voting stakers have an opportunity to remove themselves from the system in the case + * where they are on the losing side of a vote. + **/ + enactmentPeriod: u32 & AugmentedConst; + /** + * Minimum voting period allowed for a fast-track referendum. + **/ + fastTrackVotingPeriod: u32 & AugmentedConst; + /** + * Indicator for whether an emergency origin is even allowed to happen. Some chains may + * want to set this permanently to `false`, others may want to condition it on things such + * as an upgrade having happened recently. + **/ + instantAllowed: bool & AugmentedConst; + /** + * How often (in blocks) new public referenda are launched. + **/ + launchPeriod: u32 & AugmentedConst; + /** + * The maximum number of public proposals that can exist at any time. + **/ + maxProposals: u32 & AugmentedConst; + /** + * The maximum number of votes for an account. + * + * Also used to compute weight, an overly big value can + * lead to extrinsic with very big weight: see `delegate` for instance. + **/ + maxVotes: u32 & AugmentedConst; + /** + * The minimum amount to be used as a deposit for a public referendum proposal. + **/ + minimumDeposit: u128 & AugmentedConst; + /** + * The amount of balance that must be deposited per byte of preimage stored. + **/ + preimageByteDeposit: u128 & AugmentedConst; + /** + * The minimum period of vote locking. + * + * It should be no shorter than enactment period to ensure that in the case of an approval, + * those successful voters are locked into the consequences that their votes entail. + **/ + voteLockingPeriod: u32 & AugmentedConst; + /** + * How often (in blocks) to check for new votes. + **/ + votingPeriod: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + electionProviderMultiPhase: { + /** + * Maximum length (bytes) that the mined solution should consume. + * + * The miner will ensure that the total length of the unsigned solution will not exceed + * this value. + **/ + minerMaxLength: u32 & AugmentedConst; + /** + * Maximum weight that the miner should consume. + * + * The miner will ensure that the total weight of the unsigned solution will not exceed + * this value, based on [`WeightInfo::submit_unsigned`]. + **/ + minerMaxWeight: u64 & AugmentedConst; + /** + * The priority of the unsigned transaction submitted in the unsigned-phase + **/ + minerTxPriority: u64 & AugmentedConst; + /** + * The repeat threshold of the offchain worker. + * + * For example, if it is 5, that means that at least 5 blocks will elapse between attempts + * to submit the worker's solution. + **/ + offchainRepeat: u32 & AugmentedConst; + /** + * Base deposit for a signed solution. + **/ + signedDepositBase: u128 & AugmentedConst; + /** + * Per-byte deposit for a signed solution. + **/ + signedDepositByte: u128 & AugmentedConst; + /** + * Per-weight deposit for a signed solution. + **/ + signedDepositWeight: u128 & AugmentedConst; + /** + * Maximum number of signed submissions that can be queued. + * + * It is best to avoid adjusting this during an election, as it impacts downstream data + * structures. In particular, `SignedSubmissionIndices` is bounded on this value. If you + * update this value during an election, you _must_ ensure that + * `SignedSubmissionIndices.len()` is less than or equal to the new value. Otherwise, + * attempts to submit new solutions may cause a runtime panic. + **/ + signedMaxSubmissions: u32 & AugmentedConst; + /** + * Maximum weight of a signed solution. + * + * This should probably be similar to [`Config::MinerMaxWeight`]. + **/ + signedMaxWeight: u64 & AugmentedConst; + /** + * Duration of the signed phase. + **/ + signedPhase: u32 & AugmentedConst; + /** + * Base reward for a signed solution + **/ + signedRewardBase: u128 & AugmentedConst; + /** + * The minimum amount of improvement to the solution score that defines a solution as + * "better" (in any phase). + **/ + solutionImprovementThreshold: Perbill & AugmentedConst; + /** + * Duration of the unsigned phase. + **/ + unsignedPhase: u32 & AugmentedConst; + /** + * The maximum number of voters to put in the snapshot. At the moment, snapshots are only + * over a single block, but once multi-block elections are introduced they will take place + * over multiple blocks. + * + * Also, note the data type: If the voters are represented by a `u32` in `type + * CompactSolution`, the same `u32` is used here to ensure bounds are respected. + **/ + voterSnapshotPerBlock: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + gilt: { + /** + * Portion of the queue which is free from ordering and just a FIFO. + * + * Must be no greater than `MaxQueueLen`. + **/ + fifoQueueLen: u32 & AugmentedConst; + /** + * The number of blocks between consecutive attempts to issue more gilts in an effort to + * get to the target amount to be frozen. + * + * A larger value results in fewer storage hits each block, but a slower period to get to + * the target. + **/ + intakePeriod: u32 & AugmentedConst; + /** + * The maximum amount of bids that can be turned into issued gilts each block. A larger + * value here means less of the block available for transactions should there be a glut of + * bids to make into gilts to reach the target. + **/ + maxIntakeBids: u32 & AugmentedConst; + /** + * Maximum number of items that may be in each duration queue. + **/ + maxQueueLen: u32 & AugmentedConst; + /** + * The minimum amount of funds that may be offered to freeze for a gilt. Note that this + * does not actually limit the amount which may be frozen in a gilt since gilts may be + * split up in order to satisfy the desired amount of funds under gilts. + * + * It should be at least big enough to ensure that there is no possible storage spam attack + * or queue-filling attack. + **/ + minFreeze: u128 & AugmentedConst; + /** + * The base period for the duration queues. This is the common multiple across all + * supported freezing durations that can be bid upon. + **/ + period: u32 & AugmentedConst; + /** + * Number of duration queues in total. This sets the maximum duration supported, which is + * this value multiplied by `Period`. + **/ + queueCount: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + grandpa: { + /** + * Max Authorities in use + **/ + maxAuthorities: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + identity: { + /** + * The amount held on deposit for a registered identity + **/ + basicDeposit: u128 & AugmentedConst; + /** + * The amount held on deposit per additional field for a registered identity. + **/ + fieldDeposit: u128 & AugmentedConst; + /** + * Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O + * required to access an identity, but can be pretty high. + **/ + maxAdditionalFields: u32 & AugmentedConst; + /** + * Maxmimum number of registrars allowed in the system. Needed to bound the complexity + * of, e.g., updating judgements. + **/ + maxRegistrars: u32 & AugmentedConst; + /** + * The maximum number of sub-accounts allowed per identified account. + **/ + maxSubAccounts: u32 & AugmentedConst; + /** + * The amount held on deposit for a registered subaccount. This should account for the fact + * that one storage item's value will increase by the size of an account ID, and there will + * be another trie item whose value is the size of an account ID plus 32 bytes. + **/ + subAccountDeposit: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + imOnline: { + /** + * A configuration for base priority of unsigned transactions. + * + * This is exposed so that it can be tuned for particular runtime, when + * multiple pallets send unsigned transactions. + **/ + unsignedPriority: u64 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + indices: { + /** + * The deposit needed for reserving an index. + **/ + deposit: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + 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: u128 & AugmentedConst; + /** + * 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: u128 & AugmentedConst; + /** + * The maximum amount of signatories allowed in the multisig. + **/ + maxSignatories: u16 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + paras: { + unsignedPriority: u64 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + phragmenElection: { + /** + * How much should be locked up in order to submit one's candidacy. + **/ + candidacyBond: u128 & AugmentedConst; + /** + * Number of members to elect. + **/ + desiredMembers: u32 & AugmentedConst; + /** + * Number of runners_up to keep. + **/ + desiredRunnersUp: u32 & AugmentedConst; + /** + * Identifier for the elections-phragmen pallet's lock + **/ + palletId: U8aFixed & AugmentedConst; + /** + * How long each seat is kept. This defines the next block number at which an election + * round will happen. If set to zero, no elections are ever triggered and the module will + * be in passive mode. + **/ + termDuration: u32 & AugmentedConst; + /** + * Base deposit associated with voting. + * + * This should be sensibly high to economically ensure the pallet cannot be attacked by + * creating a gigantic number of votes. + **/ + votingBondBase: u128 & AugmentedConst; + /** + * The amount of bond that need to be locked for each vote (32 bytes). + **/ + votingBondFactor: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + proxy: { + /** + * 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: u128 & AugmentedConst; + /** + * 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: u128 & AugmentedConst; + /** + * The maximum amount of time-delayed announcements that are allowed to be pending. + **/ + maxPending: u32 & AugmentedConst; + /** + * The maximum amount of proxies allowed for a single account. + **/ + maxProxies: u32 & AugmentedConst; + /** + * 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: u128 & AugmentedConst; + /** + * 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: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + recovery: { + /** + * The base amount of currency needed to reserve for creating a recovery configuration. + * + * This is held for an additional storage item whose value size is + * `2 + sizeof(BlockNumber, Balance)` bytes. + **/ + configDepositBase: u128 & AugmentedConst; + /** + * The amount of currency needed per additional user when creating a recovery + * configuration. + * + * This is held for adding `sizeof(AccountId)` bytes more into a pre-existing storage + * value. + **/ + friendDepositFactor: u128 & AugmentedConst; + /** + * The maximum amount of friends allowed in a recovery configuration. + **/ + maxFriends: u16 & AugmentedConst; + /** + * The base amount of currency needed to reserve for starting a recovery. + * + * This is primarily held for deterring malicious recovery attempts, and should + * have a value large enough that a bad actor would choose not to place this + * deposit. It also acts to fund additional storage item whose value size is + * `sizeof(BlockNumber, Balance + T * AccountId)` bytes. Where T is a configurable + * threshold. + **/ + recoveryDeposit: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + registrar: { + /** + * The deposit to be paid per byte stored on chain. + **/ + dataDepositPerByte: u128 & AugmentedConst; + /** + * The deposit to be paid to run a parathread. + * This should include the cost for storing the genesis head and validation code. + **/ + paraDeposit: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + scheduler: { + /** + * The maximum weight that may be scheduled per block for any dispatchables of less + * priority than `schedule::HARD_DEADLINE`. + **/ + maximumWeight: u64 & AugmentedConst; + /** + * The maximum number of scheduled calls in the queue for a single block. + * Not strictly enforced, but used for weight estimation. + **/ + maxScheduledPerBlock: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + slots: { + /** + * The number of blocks to offset each lease period by. + **/ + leaseOffset: u32 & AugmentedConst; + /** + * The number of blocks over which a single period lasts. + **/ + leasePeriod: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + society: { + /** + * The minimum amount of a deposit required for a bid to be made. + **/ + candidateDeposit: u128 & AugmentedConst; + /** + * The number of blocks between membership challenges. + **/ + challengePeriod: u32 & AugmentedConst; + /** + * The maximum number of candidates that we accept per round. + **/ + maxCandidateIntake: u32 & AugmentedConst; + /** + * The maximum duration of the payout lock. + **/ + maxLockDuration: u32 & AugmentedConst; + /** + * The number of times a member may vote the wrong way (or not at all, when they are a + * skeptic) before they become suspended. + **/ + maxStrikes: u32 & AugmentedConst; + /** + * The societies's pallet id + **/ + palletId: FrameSupportPalletId & AugmentedConst; + /** + * The amount of incentive paid within each period. Doesn't include VoterTip. + **/ + periodSpend: u128 & AugmentedConst; + /** + * The number of blocks between candidate/membership rotation periods. + **/ + rotationPeriod: u32 & AugmentedConst; + /** + * The amount of the unpaid reward that gets deducted in the case that either a skeptic + * doesn't vote or someone votes in the wrong way. + **/ + wrongSideDeduction: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + staking: { + /** + * Number of eras that staked funds must remain bonded for. + **/ + bondingDuration: u32 & AugmentedConst; + maxNominations: u32 & AugmentedConst; + /** + * The maximum number of nominators rewarded for each validator. + * + * For each validator only the `$MaxNominatorRewardedPerValidator` biggest stakers can + * claim their reward. This used to limit the i/o cost for the nominator payout. + **/ + maxNominatorRewardedPerValidator: u32 & AugmentedConst; + /** + * Number of sessions per era. + **/ + sessionsPerEra: u32 & AugmentedConst; + /** + * Number of eras that slashes are deferred by, after computation. + * + * This should be less than the bonding duration. Set to 0 if slashes + * should be applied immediately, without opportunity for intervention. + **/ + slashDeferDuration: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + system: { + /** + * Maximum number of block number to block hash mappings to keep (oldest pruned first). + **/ + blockHashCount: u32 & AugmentedConst; + /** + * The maximum length of a block (in bytes). + **/ + blockLength: FrameSystemLimitsBlockLength & AugmentedConst; + /** + * Block & extrinsics weights: base values and limits. + **/ + blockWeights: FrameSystemLimitsBlockWeights & AugmentedConst; + /** + * The weight of runtime database operations the runtime can invoke. + **/ + dbWeight: FrameSupportWeightsRuntimeDbWeight & AugmentedConst; + /** + * The designated SS85 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: u16 & AugmentedConst; + /** + * Get the chain's current version. + **/ + version: SpVersionRuntimeVersion & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + timestamp: { + /** + * The minimum period between blocks. Beware that this is different to the *expected* + * period that the block production apparatus provides. Your chosen consensus system will + * generally work with this to determine a sensible block time. e.g. For Aura, it will be + * double this period on default settings. + **/ + minimumPeriod: u64 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + tips: { + /** + * The amount held on deposit per byte within the tip report reason or bounty description. + **/ + dataDepositPerByte: u128 & AugmentedConst; + /** + * Maximum acceptable reason length. + * + * Benchmarks depend on this value, be sure to update weights file when changing this value + **/ + maximumReasonLength: u32 & AugmentedConst; + /** + * The period for which a tip remains open after is has achieved threshold tippers. + **/ + tipCountdown: u32 & AugmentedConst; + /** + * The percent of the final tip which goes to the original reporter of the tip. + **/ + tipFindersFee: Percent & AugmentedConst; + /** + * The amount held on deposit for placing a tip report. + **/ + tipReportDepositBase: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + transactionPayment: { + /** + * A fee mulitplier for `Operational` extrinsics to compute "virtual tip" to boost their + * `priority` + * + * This value is multipled by the `final_fee` to obtain a "virtual tip" that is later + * added to a tip component in regular `priority` calculations. + * It means that a `Normal` transaction can front-run a similarly-sized `Operational` + * extrinsic (with no tip), by including a tip value greater than the virtual tip. + * + * ```rust,ignore + * // For `Normal` + * let priority = priority_calc(tip); + * + * // For `Operational` + * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier; + * let priority = priority_calc(tip + virtual_tip); + * ``` + * + * Note that since we use `final_fee` the multiplier applies also to the regular `tip` + * sent with the transaction. So, not only does the transaction get a priority bump based + * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational` + * transactions. + **/ + operationalFeeMultiplier: u8 & AugmentedConst; + /** + * The fee to be paid for making a transaction; the per-byte portion. + **/ + transactionByteFee: u128 & AugmentedConst; + /** + * The polynomial that is applied in order to derive fee from weight. + **/ + weightToFee: Vec & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + treasury: { + /** + * Percentage of spare funds (if any) that are burnt per spend period. + **/ + burn: Permill & AugmentedConst; + /** + * The maximum number of approvals that can wait in the spending queue. + **/ + maxApprovals: u32 & AugmentedConst; + /** + * The treasury's pallet id, used for deriving its sovereign account ID. + **/ + palletId: FrameSupportPalletId & AugmentedConst; + /** + * Fraction of a proposal's value that should be bonded in order to place the proposal. + * An accepted proposal gets these back. A rejected proposal does not. + **/ + proposalBond: Permill & AugmentedConst; + /** + * Minimum amount of funds that should be placed in a deposit for making a proposal. + **/ + proposalBondMinimum: u128 & AugmentedConst; + /** + * Period between successive spends. + **/ + spendPeriod: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + utility: { + /** + * The limit on the number of batched calls. + **/ + batchedCallsLimit: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + vesting: { + maxVestingSchedules: u32 & AugmentedConst; + /** + * The minimum amount transferred to call `vested_transfer`. + **/ + minVestedTransfer: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + } // AugmentedConsts +} // declare module diff --git a/packages/api-augment/src/kusama/errors.ts b/packages/api-augment/src/kusama/errors.ts new file mode 100644 index 0000000000..ccf765312e --- /dev/null +++ b/packages/api-augment/src/kusama/errors.ts @@ -0,0 +1,1859 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; + +declare module '@polkadot/api-base/types/errors' { + export interface AugmentedErrors { + auctions: { + /** + * The para is already leased out for part of this range. + **/ + AlreadyLeasedOut: AugmentedError; + /** + * Auction has already ended. + **/ + AuctionEnded: AugmentedError; + /** + * This auction is already in progress. + **/ + AuctionInProgress: AugmentedError; + /** + * The lease period is in the past. + **/ + LeasePeriodInPast: AugmentedError; + /** + * Not an auction. + **/ + NotAuction: AugmentedError; + /** + * Not a current auction. + **/ + NotCurrentAuction: AugmentedError; + /** + * Para is not registered + **/ + ParaNotRegistered: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + authorship: { + /** + * The uncle is genesis. + **/ + GenesisUncle: AugmentedError; + /** + * The uncle parent not in the chain. + **/ + InvalidUncleParent: AugmentedError; + /** + * The uncle isn't recent enough to be included. + **/ + OldUncle: AugmentedError; + /** + * The uncle is too high in chain. + **/ + TooHighUncle: AugmentedError; + /** + * Too many uncles. + **/ + TooManyUncles: AugmentedError; + /** + * The uncle is already included. + **/ + UncleAlreadyIncluded: AugmentedError; + /** + * Uncles already set in the block. + **/ + UnclesAlreadySet: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + babe: { + /** + * A given equivocation report is valid but already previously reported. + **/ + DuplicateOffenceReport: AugmentedError; + /** + * An equivocation proof provided as part of an equivocation report is invalid. + **/ + InvalidEquivocationProof: AugmentedError; + /** + * A key ownership proof provided as part of an equivocation report is invalid. + **/ + InvalidKeyOwnershipProof: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + bagsList: { + /** + * Id not found in list. + **/ + IdNotFound: AugmentedError; + /** + * An Id does not have a greater vote weight than another Id. + **/ + NotHeavier: AugmentedError; + /** + * Attempted to place node in front of a node in another bag. + **/ + NotInSameBag: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + balances: { + /** + * Beneficiary account must pre-exist + **/ + DeadAccount: AugmentedError; + /** + * Value too low to create account due to existential deposit + **/ + ExistentialDeposit: AugmentedError; + /** + * A vesting schedule already exists for this account + **/ + ExistingVestingSchedule: AugmentedError; + /** + * Balance too low to send value + **/ + InsufficientBalance: AugmentedError; + /** + * Transfer/payment would kill account + **/ + KeepAlive: AugmentedError; + /** + * Account liquidity restrictions prevent withdrawal + **/ + LiquidityRestrictions: AugmentedError; + /** + * Number of named reserves exceed MaxReserves + **/ + TooManyReserves: AugmentedError; + /** + * Vesting balance too high to send value + **/ + VestingBalance: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + bounties: { + /** + * The bounty cannot be closed because it has active child-bounties. + **/ + HasActiveChildBounty: AugmentedError; + /** + * Proposer's balance is too low. + **/ + InsufficientProposersBalance: AugmentedError; + /** + * Invalid bounty fee. + **/ + InvalidFee: AugmentedError; + /** + * No proposal or bounty at that index. + **/ + InvalidIndex: AugmentedError; + /** + * Invalid bounty value. + **/ + InvalidValue: AugmentedError; + /** + * A bounty payout is pending. + * To cancel the bounty, you must unassign and slash the curator. + **/ + PendingPayout: AugmentedError; + /** + * The bounties cannot be claimed/closed because it's still in the countdown period. + **/ + Premature: AugmentedError; + /** + * The reason given is just too big. + **/ + ReasonTooBig: AugmentedError; + /** + * Require bounty curator. + **/ + RequireCurator: AugmentedError; + /** + * The bounty status is unexpected. + **/ + UnexpectedStatus: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + claims: { + /** + * Invalid Ethereum signature. + **/ + InvalidEthereumSignature: AugmentedError; + /** + * A needed statement was not included. + **/ + InvalidStatement: AugmentedError; + /** + * There's not enough in the pot to pay out some unvested amount. Generally implies a logic + * error. + **/ + PotUnderflow: AugmentedError; + /** + * Account ID sending transaction has no claim. + **/ + SenderHasNoClaim: AugmentedError; + /** + * Ethereum address has no claim. + **/ + SignerHasNoClaim: AugmentedError; + /** + * The account already has a vested balance. + **/ + VestedBalanceExists: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + configuration: { + /** + * The new value for a configuration parameter is invalid. + **/ + InvalidNewValue: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + council: { + /** + * Members are already initialized! + **/ + AlreadyInitialized: AugmentedError; + /** + * Duplicate proposals not allowed + **/ + DuplicateProposal: AugmentedError; + /** + * Duplicate vote ignored + **/ + DuplicateVote: AugmentedError; + /** + * Account is not a member + **/ + NotMember: AugmentedError; + /** + * Proposal must exist + **/ + ProposalMissing: AugmentedError; + /** + * The close call was made too early, before the end of the voting. + **/ + TooEarly: AugmentedError; + /** + * There can only be a maximum of `MaxProposals` active proposals. + **/ + TooManyProposals: AugmentedError; + /** + * Mismatched index + **/ + WrongIndex: AugmentedError; + /** + * The given length bound for the proposal was too low. + **/ + WrongProposalLength: AugmentedError; + /** + * The given weight bound for the proposal was too low. + **/ + WrongProposalWeight: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + crowdloan: { + /** + * The fund is already in `NewRaise` + **/ + AlreadyInNewRaise: AugmentedError; + /** + * This parachain's bid or lease is still active and withdraw cannot yet begin. + **/ + BidOrLeaseActive: AugmentedError; + /** + * The campaign ends before the current block number. The end must be in the future. + **/ + CannotEndInPast: AugmentedError; + /** + * Contributions exceed maximum amount. + **/ + CapExceeded: AugmentedError; + /** + * The contribution period has already ended. + **/ + ContributionPeriodOver: AugmentedError; + /** + * The contribution was below the minimum, `MinContribution`. + **/ + ContributionTooSmall: AugmentedError; + /** + * The end date for this crowdloan is not sensible. + **/ + EndTooFarInFuture: AugmentedError; + /** + * The current lease period is more than the first lease period. + **/ + FirstPeriodInPast: AugmentedError; + /** + * The first lease period needs to at least be less than 3 `max_value`. + **/ + FirstPeriodTooFarInFuture: AugmentedError; + /** + * The crowdloan has not yet ended. + **/ + FundNotEnded: AugmentedError; + /** + * The origin of this call is invalid. + **/ + InvalidOrigin: AugmentedError; + /** + * Invalid fund index. + **/ + InvalidParaId: AugmentedError; + /** + * Invalid signature. + **/ + InvalidSignature: AugmentedError; + /** + * Last lease period must be greater than first lease period. + **/ + LastPeriodBeforeFirstPeriod: AugmentedError; + /** + * The last lease period cannot be more than 3 periods after the first period. + **/ + LastPeriodTooFarInFuture: AugmentedError; + /** + * This parachain lease is still active and retirement cannot yet begin. + **/ + LeaseActive: AugmentedError; + /** + * The provided memo is too large. + **/ + MemoTooLarge: AugmentedError; + /** + * There are no contributions stored in this crowdloan. + **/ + NoContributions: AugmentedError; + /** + * A lease period has not started yet, due to an offset in the starting block. + **/ + NoLeasePeriod: AugmentedError; + /** + * This crowdloan does not correspond to a parachain. + **/ + NotParachain: AugmentedError; + /** + * The crowdloan is not ready to dissolve. Potentially still has a slot or in retirement period. + **/ + NotReadyToDissolve: AugmentedError; + /** + * There was an overflow. + **/ + Overflow: AugmentedError; + /** + * No contributions allowed during the VRF delay + **/ + VrfDelayInProgress: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + democracy: { + /** + * Cannot cancel the same proposal twice + **/ + AlreadyCanceled: AugmentedError; + /** + * The account is already delegating. + **/ + AlreadyDelegating: AugmentedError; + /** + * Identity may not veto a proposal twice + **/ + AlreadyVetoed: AugmentedError; + /** + * Preimage already noted + **/ + DuplicatePreimage: AugmentedError; + /** + * Proposal already made + **/ + DuplicateProposal: AugmentedError; + /** + * Imminent + **/ + Imminent: AugmentedError; + /** + * The instant referendum origin is currently disallowed. + **/ + InstantNotAllowed: AugmentedError; + /** + * Too high a balance was provided that the account cannot afford. + **/ + InsufficientFunds: AugmentedError; + /** + * Invalid hash + **/ + InvalidHash: AugmentedError; + /** + * Maximum number of votes reached. + **/ + MaxVotesReached: AugmentedError; + /** + * No proposals waiting + **/ + NoneWaiting: AugmentedError; + /** + * Delegation to oneself makes no sense. + **/ + Nonsense: AugmentedError; + /** + * The actor has no permission to conduct the action. + **/ + NoPermission: AugmentedError; + /** + * No external proposal + **/ + NoProposal: AugmentedError; + /** + * The account is not currently delegating. + **/ + NotDelegating: AugmentedError; + /** + * Not imminent + **/ + NotImminent: AugmentedError; + /** + * Next external proposal not simple majority + **/ + NotSimpleMajority: AugmentedError; + /** + * The given account did not vote on the referendum. + **/ + NotVoter: AugmentedError; + /** + * Invalid preimage + **/ + PreimageInvalid: AugmentedError; + /** + * Preimage not found + **/ + PreimageMissing: AugmentedError; + /** + * Proposal still blacklisted + **/ + ProposalBlacklisted: AugmentedError; + /** + * Proposal does not exist + **/ + ProposalMissing: AugmentedError; + /** + * Vote given for invalid referendum + **/ + ReferendumInvalid: AugmentedError; + /** + * Too early + **/ + TooEarly: AugmentedError; + /** + * Maximum number of proposals reached. + **/ + TooManyProposals: AugmentedError; + /** + * Value too low + **/ + ValueLow: AugmentedError; + /** + * The account currently has votes attached to it and the operation cannot succeed until + * these are removed, either through `unvote` or `reap_vote`. + **/ + VotesExist: AugmentedError; + /** + * Invalid upper bound. + **/ + WrongUpperBound: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + electionProviderMultiPhase: { + /** + * The call is not allowed at this point. + **/ + CallNotAllowed: AugmentedError; + /** + * `Self::insert_submission` returned an invalid index. + **/ + InvalidSubmissionIndex: AugmentedError; + /** + * Snapshot metadata should exist but didn't. + **/ + MissingSnapshotMetadata: AugmentedError; + /** + * OCW submitted solution for wrong round + **/ + OcwCallWrongEra: AugmentedError; + /** + * Submission was too early. + **/ + PreDispatchEarlySubmission: AugmentedError; + /** + * Submission was too weak, score-wise. + **/ + PreDispatchWeakSubmission: AugmentedError; + /** + * Wrong number of winners presented. + **/ + PreDispatchWrongWinnerCount: AugmentedError; + /** + * The origin failed to pay the deposit. + **/ + SignedCannotPayDeposit: AugmentedError; + /** + * Witness data to dispatchable is invalid. + **/ + SignedInvalidWitness: AugmentedError; + /** + * The queue was full, and the solution was not better than any of the existing ones. + **/ + SignedQueueFull: AugmentedError; + /** + * The signed submission consumes too much weight + **/ + SignedTooMuchWeight: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + gilt: { + /** + * The amount of the bid is less than the minimum allowed. + **/ + AmountTooSmall: AugmentedError; + /** + * The queue for the bid's duration is full and the amount bid is too low to get in + * through replacing an existing bid. + **/ + BidTooLow: AugmentedError; + /** + * The duration is the bid is greater than the number of queues. + **/ + DurationTooBig: AugmentedError; + /** + * The duration of the bid is less than one. + **/ + DurationTooSmall: AugmentedError; + /** + * Gilt not yet at expiry date. + **/ + NotExpired: AugmentedError; + /** + * The given bid for retraction is not found. + **/ + NotFound: AugmentedError; + /** + * Not the owner of the gilt. + **/ + NotOwner: AugmentedError; + /** + * Gilt index is unknown. + **/ + Unknown: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + grandpa: { + /** + * Attempt to signal GRANDPA change with one already pending. + **/ + ChangePending: AugmentedError; + /** + * A given equivocation report is valid but already previously reported. + **/ + DuplicateOffenceReport: AugmentedError; + /** + * An equivocation proof provided as part of an equivocation report is invalid. + **/ + InvalidEquivocationProof: AugmentedError; + /** + * A key ownership proof provided as part of an equivocation report is invalid. + **/ + InvalidKeyOwnershipProof: AugmentedError; + /** + * Attempt to signal GRANDPA pause when the authority set isn't live + * (either paused or already pending pause). + **/ + PauseFailed: AugmentedError; + /** + * Attempt to signal GRANDPA resume when the authority set isn't paused + * (either live or already pending resume). + **/ + ResumeFailed: AugmentedError; + /** + * Cannot signal forced change so soon after last. + **/ + TooSoon: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + hrmp: { + /** + * The channel is already confirmed. + **/ + AcceptHrmpChannelAlreadyConfirmed: AugmentedError; + /** + * The channel from the sender to the origin doesn't exist. + **/ + AcceptHrmpChannelDoesntExist: AugmentedError; + /** + * The recipient already has the maximum number of allowed inbound channels. + **/ + AcceptHrmpChannelLimitExceeded: AugmentedError; + /** + * Canceling is requested by neither the sender nor recipient of the open channel request. + **/ + CancelHrmpOpenChannelUnauthorized: AugmentedError; + /** + * The channel close request is already requested. + **/ + CloseHrmpChannelAlreadyUnderway: AugmentedError; + /** + * The channel to be closed doesn't exist. + **/ + CloseHrmpChannelDoesntExist: AugmentedError; + /** + * The origin tries to close a channel where it is neither the sender nor the recipient. + **/ + CloseHrmpChannelUnauthorized: AugmentedError; + /** + * Cannot cancel an HRMP open channel request because it is already confirmed. + **/ + OpenHrmpChannelAlreadyConfirmed: AugmentedError; + /** + * The channel already exists + **/ + OpenHrmpChannelAlreadyExists: AugmentedError; + /** + * There is already a request to open the same channel. + **/ + OpenHrmpChannelAlreadyRequested: AugmentedError; + /** + * The requested capacity exceeds the global limit. + **/ + OpenHrmpChannelCapacityExceedsLimit: AugmentedError; + /** + * The open request doesn't exist. + **/ + OpenHrmpChannelDoesntExist: AugmentedError; + /** + * The recipient is not a valid para. + **/ + OpenHrmpChannelInvalidRecipient: AugmentedError; + /** + * The sender already has the maximum number of allowed outbound channels. + **/ + OpenHrmpChannelLimitExceeded: AugmentedError; + /** + * The open request requested the message size that exceeds the global limit. + **/ + OpenHrmpChannelMessageSizeExceedsLimit: AugmentedError; + /** + * The sender tried to open a channel to themselves. + **/ + OpenHrmpChannelToSelf: AugmentedError; + /** + * The requested capacity is zero. + **/ + OpenHrmpChannelZeroCapacity: AugmentedError; + /** + * The requested maximum message size is 0. + **/ + OpenHrmpChannelZeroMessageSize: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + identity: { + /** + * Account ID is already named. + **/ + AlreadyClaimed: AugmentedError; + /** + * Empty index. + **/ + EmptyIndex: AugmentedError; + /** + * Fee is changed. + **/ + FeeChanged: AugmentedError; + /** + * The index is invalid. + **/ + InvalidIndex: AugmentedError; + /** + * Invalid judgement. + **/ + InvalidJudgement: AugmentedError; + /** + * The target is invalid. + **/ + InvalidTarget: AugmentedError; + /** + * Judgement given. + **/ + JudgementGiven: AugmentedError; + /** + * No identity found. + **/ + NoIdentity: AugmentedError; + /** + * Account isn't found. + **/ + NotFound: AugmentedError; + /** + * Account isn't named. + **/ + NotNamed: AugmentedError; + /** + * Sub-account isn't owned by sender. + **/ + NotOwned: AugmentedError; + /** + * Sender is not a sub-account. + **/ + NotSub: AugmentedError; + /** + * Sticky judgement. + **/ + StickyJudgement: AugmentedError; + /** + * Too many additional fields. + **/ + TooManyFields: AugmentedError; + /** + * Maximum amount of registrars reached. Cannot add any more. + **/ + TooManyRegistrars: AugmentedError; + /** + * Too many subs-accounts. + **/ + TooManySubAccounts: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + imOnline: { + /** + * Duplicated heartbeat. + **/ + DuplicatedHeartbeat: AugmentedError; + /** + * Non existent public key. + **/ + InvalidKey: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + indices: { + /** + * The index was not available. + **/ + InUse: AugmentedError; + /** + * The index was not already assigned. + **/ + NotAssigned: AugmentedError; + /** + * The index is assigned to another account. + **/ + NotOwner: AugmentedError; + /** + * The source and destination accounts are identical. + **/ + NotTransfer: AugmentedError; + /** + * The index is permanent and may not be freed/changed. + **/ + Permanent: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + multisig: { + /** + * Call is already approved by this signatory. + **/ + AlreadyApproved: AugmentedError; + /** + * The data to be stored is already stored. + **/ + AlreadyStored: AugmentedError; + /** + * The maximum weight information provided was too low. + **/ + MaxWeightTooLow: AugmentedError; + /** + * Threshold must be 2 or greater. + **/ + MinimumThreshold: AugmentedError; + /** + * Call doesn't need any (more) approvals. + **/ + NoApprovalsNeeded: AugmentedError; + /** + * Multisig operation not found when attempting to cancel. + **/ + NotFound: AugmentedError; + /** + * No timepoint was given, yet the multisig operation is already underway. + **/ + NoTimepoint: AugmentedError; + /** + * Only the account that originally created the multisig is able to cancel it. + **/ + NotOwner: AugmentedError; + /** + * The sender was contained in the other signatories; it shouldn't be. + **/ + SenderInSignatories: AugmentedError; + /** + * The signatories were provided out of order; they should be ordered. + **/ + SignatoriesOutOfOrder: AugmentedError; + /** + * There are too few signatories in the list. + **/ + TooFewSignatories: AugmentedError; + /** + * There are too many signatories in the list. + **/ + TooManySignatories: AugmentedError; + /** + * A timepoint was given, yet no multisig operation is underway. + **/ + UnexpectedTimepoint: AugmentedError; + /** + * A different timepoint was given to the multisig operation that is underway. + **/ + WrongTimepoint: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + paraInclusion: { + /** + * Multiple bitfields submitted by same validator or validators out of order by index. + **/ + BitfieldDuplicateOrUnordered: AugmentedError; + /** + * A bitfield that references a freed core, + * either intentionally or as part of a concluded + * invalid dispute. + **/ + BitfieldReferencesFreedCore: AugmentedError; + /** + * Candidate not in parent context. + **/ + CandidateNotInParentContext: AugmentedError; + /** + * Candidate scheduled despite pending candidate already existing for the para. + **/ + CandidateScheduledBeforeParaFree: AugmentedError; + /** + * Head data exceeds the configured maximum. + **/ + HeadDataTooLarge: AugmentedError; + /** + * The candidate didn't follow the rules of HRMP watermark advancement. + **/ + HrmpWatermarkMishandling: AugmentedError; + /** + * The downward message queue is not processed correctly. + **/ + IncorrectDownwardMessageHandling: AugmentedError; + /** + * Insufficient (non-majority) backing. + **/ + InsufficientBacking: AugmentedError; + /** + * Invalid (bad signature, unknown validator, etc.) backing. + **/ + InvalidBacking: AugmentedError; + /** + * Invalid signature + **/ + InvalidBitfieldSignature: AugmentedError; + /** + * Invalid group index in core assignment. + **/ + InvalidGroupIndex: AugmentedError; + /** + * The HRMP messages sent by the candidate is not valid. + **/ + InvalidOutboundHrmp: AugmentedError; + /** + * At least one upward message sent does not pass the acceptance criteria. + **/ + InvalidUpwardMessages: AugmentedError; + /** + * The validation code hash of the candidate is not valid. + **/ + InvalidValidationCodeHash: AugmentedError; + /** + * Output code is too large + **/ + NewCodeTooLarge: AugmentedError; + /** + * Collator did not sign PoV. + **/ + NotCollatorSigned: AugmentedError; + /** + * The `para_head` hash in the candidate descriptor doesn't match the hash of the actual para head in the + * commitments. + **/ + ParaHeadMismatch: AugmentedError; + /** + * Code upgrade prematurely. + **/ + PrematureCodeUpgrade: AugmentedError; + /** + * Scheduled cores out of order. + **/ + ScheduledOutOfOrder: AugmentedError; + /** + * Candidate submitted but para not scheduled. + **/ + UnscheduledCandidate: AugmentedError; + /** + * The validation data hash does not match expected. + **/ + ValidationDataHashMismatch: AugmentedError; + /** + * Validator index out of bounds. + **/ + ValidatorIndexOutOfBounds: AugmentedError; + /** + * Availability bitfield has unexpected size. + **/ + WrongBitfieldSize: AugmentedError; + /** + * Candidate included with the wrong collator. + **/ + WrongCollator: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + paraInherent: { + /** + * Disputed candidate that was concluded invalid. + **/ + CandidateConcludedInvalid: AugmentedError; + /** + * The data given to the inherent will result in an overweight block. + **/ + InherentOverweight: AugmentedError; + /** + * The hash of the submitted parent header doesn't correspond to the saved block hash of + * the parent. + **/ + InvalidParentHeader: AugmentedError; + /** + * Inclusion inherent called more than once per block. + **/ + TooManyInclusionInherents: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + paras: { + /** + * Para cannot be downgraded to a parathread. + **/ + CannotDowngrade: AugmentedError; + /** + * Para cannot be offboarded at this time. + **/ + CannotOffboard: AugmentedError; + /** + * Para cannot be onboarded because it is already tracked by our system. + **/ + CannotOnboard: AugmentedError; + /** + * Para cannot be upgraded to a parachain. + **/ + CannotUpgrade: AugmentedError; + /** + * Para is not registered in our system. + **/ + NotRegistered: AugmentedError; + /** + * The given validator already has cast a vote. + **/ + PvfCheckDoubleVote: AugmentedError; + /** + * The signature for the PVF pre-checking is invalid. + **/ + PvfCheckInvalidSignature: AugmentedError; + /** + * The statement for PVF pre-checking is for a future session. + **/ + PvfCheckStatementFuture: AugmentedError; + /** + * The statement for PVF pre-checking is stale. + **/ + PvfCheckStatementStale: AugmentedError; + /** + * The given PVF does not exist at the moment of process a vote. + **/ + PvfCheckSubjectInvalid: AugmentedError; + /** + * Claimed validator index is out of bounds. + **/ + PvfCheckValidatorIndexOutOfBounds: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + parasDisputes: { + /** + * Ancient dispute statement provided. + **/ + AncientDisputeStatement: AugmentedError; + /** + * Duplicate dispute statement sets provided. + **/ + DuplicateDisputeStatementSets: AugmentedError; + /** + * Validator vote submitted more than once to dispute. + **/ + DuplicateStatement: AugmentedError; + /** + * Invalid signature on statement. + **/ + InvalidSignature: AugmentedError; + /** + * Too many spam slots used by some specific validator. + **/ + PotentialSpam: AugmentedError; + /** + * A dispute where there are only votes on one side. + **/ + SingleSidedDispute: AugmentedError; + /** + * Validator index on statement is out of bounds for session. + **/ + ValidatorIndexOutOfBounds: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + phragmenElection: { + /** + * Duplicated candidate submission. + **/ + DuplicatedCandidate: AugmentedError; + /** + * Candidate does not have enough funds. + **/ + InsufficientCandidateFunds: AugmentedError; + /** + * The renouncing origin presented a wrong `Renouncing` parameter. + **/ + InvalidRenouncing: AugmentedError; + /** + * Prediction regarding replacement after member removal is wrong. + **/ + InvalidReplacement: AugmentedError; + /** + * The provided count of number of votes is incorrect. + **/ + InvalidVoteCount: AugmentedError; + /** + * The provided count of number of candidates is incorrect. + **/ + InvalidWitnessData: AugmentedError; + /** + * Cannot vote with stake less than minimum balance. + **/ + LowBalance: AugmentedError; + /** + * Cannot vote more than maximum allowed. + **/ + MaximumVotesExceeded: AugmentedError; + /** + * Member cannot re-submit candidacy. + **/ + MemberSubmit: AugmentedError; + /** + * Must be a voter. + **/ + MustBeVoter: AugmentedError; + /** + * Not a member. + **/ + NotMember: AugmentedError; + /** + * Must vote for at least one candidate. + **/ + NoVotes: AugmentedError; + /** + * Cannot report self. + **/ + ReportSelf: AugmentedError; + /** + * Runner cannot re-submit candidacy. + **/ + RunnerUpSubmit: AugmentedError; + /** + * Cannot vote more than candidates. + **/ + TooManyVotes: AugmentedError; + /** + * Voter can not pay voting bond. + **/ + UnableToPayBond: AugmentedError; + /** + * Cannot vote when no candidates or members exist. + **/ + UnableToVote: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + preimage: { + /** + * Preimage has already been noted on-chain. + **/ + AlreadyNoted: AugmentedError; + /** + * The user is not authorized to perform this action. + **/ + NotAuthorized: AugmentedError; + /** + * The preimage cannot be removed since it has not yet been noted. + **/ + NotNoted: AugmentedError; + /** + * The preimage request cannot be removed since no outstanding requests exist. + **/ + NotRequested: AugmentedError; + /** + * A preimage may not be removed when there are outstanding requests. + **/ + Requested: AugmentedError; + /** + * Preimage is too large to store on-chain. + **/ + TooLarge: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + proxy: { + /** + * Account is already a proxy. + **/ + Duplicate: AugmentedError; + /** + * Call may not be made by proxy because it may escalate its privileges. + **/ + NoPermission: AugmentedError; + /** + * Cannot add self as proxy. + **/ + NoSelfProxy: AugmentedError; + /** + * Proxy registration not found. + **/ + NotFound: AugmentedError; + /** + * Sender is not a proxy of the account to be proxied. + **/ + NotProxy: AugmentedError; + /** + * There are too many proxies registered or too many announcements pending. + **/ + TooMany: AugmentedError; + /** + * Announcement, if made at all, was made too recently. + **/ + Unannounced: AugmentedError; + /** + * A call which is incompatible with the proxy type's filter was attempted. + **/ + Unproxyable: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + recovery: { + /** + * This account is already set up for recovery + **/ + AlreadyProxy: AugmentedError; + /** + * This account is already set up for recovery + **/ + AlreadyRecoverable: AugmentedError; + /** + * A recovery process has already started for this account + **/ + AlreadyStarted: AugmentedError; + /** + * This user has already vouched for this recovery + **/ + AlreadyVouched: AugmentedError; + /** + * Some internal state is broken. + **/ + BadState: AugmentedError; + /** + * The friend must wait until the delay period to vouch for this recovery + **/ + DelayPeriod: AugmentedError; + /** + * Friends list must be less than max friends + **/ + MaxFriends: AugmentedError; + /** + * User is not allowed to make a call on behalf of this account + **/ + NotAllowed: AugmentedError; + /** + * Friends list must be greater than zero and threshold + **/ + NotEnoughFriends: AugmentedError; + /** + * This account is not a friend who can vouch + **/ + NotFriend: AugmentedError; + /** + * This account is not set up for recovery + **/ + NotRecoverable: AugmentedError; + /** + * Friends list must be sorted and free of duplicates + **/ + NotSorted: AugmentedError; + /** + * A recovery process has not started for this rescuer + **/ + NotStarted: AugmentedError; + /** + * There are still active recovery attempts that need to be closed + **/ + StillActive: AugmentedError; + /** + * The threshold for recovering this account has not been met + **/ + Threshold: AugmentedError; + /** + * Threshold must be greater than zero + **/ + ZeroThreshold: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + registrar: { + /** + * The ID is already registered. + **/ + AlreadyRegistered: AugmentedError; + /** + * Cannot deregister para + **/ + CannotDeregister: AugmentedError; + /** + * Cannot schedule downgrade of parachain to parathread + **/ + CannotDowngrade: AugmentedError; + /** + * Cannot schedule upgrade of parathread to parachain + **/ + CannotUpgrade: AugmentedError; + /** + * Invalid para code size. + **/ + CodeTooLarge: AugmentedError; + /** + * Registering parachain with empty code is not allowed. + **/ + EmptyCode: AugmentedError; + /** + * Invalid para head data size. + **/ + HeadDataTooLarge: AugmentedError; + /** + * The caller is not the owner of this Id. + **/ + NotOwner: AugmentedError; + /** + * Para is not a Parachain. + **/ + NotParachain: AugmentedError; + /** + * Para is not a Parathread. + **/ + NotParathread: AugmentedError; + /** + * The ID is not registered. + **/ + NotRegistered: AugmentedError; + /** + * The ID given for registration has not been reserved. + **/ + NotReserved: AugmentedError; + /** + * Para is locked from manipulation by the manager. Must use parachain or relay chain governance. + **/ + ParaLocked: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + scheduler: { + /** + * Failed to schedule a call + **/ + FailedToSchedule: AugmentedError; + /** + * Cannot find the scheduled call. + **/ + NotFound: AugmentedError; + /** + * Reschedule failed because it does not change scheduled time. + **/ + RescheduleNoChange: AugmentedError; + /** + * Given target block number is in the past. + **/ + TargetBlockNumberInPast: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + session: { + /** + * Registered duplicate key. + **/ + DuplicatedKey: AugmentedError; + /** + * Invalid ownership proof. + **/ + InvalidProof: AugmentedError; + /** + * Key setting account is not live, so it's impossible to associate keys. + **/ + NoAccount: AugmentedError; + /** + * No associated validator ID for account. + **/ + NoAssociatedValidatorId: AugmentedError; + /** + * No keys are associated with this account. + **/ + NoKeys: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + slots: { + /** + * There was an error with the lease. + **/ + LeaseError: AugmentedError; + /** + * The parachain ID is not onboarding. + **/ + ParaNotOnboarding: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + society: { + /** + * User has already made a bid. + **/ + AlreadyBid: AugmentedError; + /** + * User is already a candidate. + **/ + AlreadyCandidate: AugmentedError; + /** + * Society already founded. + **/ + AlreadyFounded: AugmentedError; + /** + * User is already a member. + **/ + AlreadyMember: AugmentedError; + /** + * Member is already vouching or banned from vouching again. + **/ + AlreadyVouching: AugmentedError; + /** + * An incorrect position was provided. + **/ + BadPosition: AugmentedError; + /** + * Cannot remove the founder. + **/ + Founder: AugmentedError; + /** + * Cannot remove the head of the chain. + **/ + Head: AugmentedError; + /** + * Not enough in pot to accept candidate. + **/ + InsufficientPot: AugmentedError; + /** + * Too many members in the society. + **/ + MaxMembers: AugmentedError; + /** + * Nothing to payout. + **/ + NoPayout: AugmentedError; + /** + * User is not a candidate. + **/ + NotCandidate: AugmentedError; + /** + * The caller is not the founder. + **/ + NotFounder: AugmentedError; + /** + * The caller is not the head. + **/ + NotHead: AugmentedError; + /** + * User is not a member. + **/ + NotMember: AugmentedError; + /** + * User is not suspended. + **/ + NotSuspended: AugmentedError; + /** + * Member is not vouching. + **/ + NotVouching: AugmentedError; + /** + * User is suspended. + **/ + Suspended: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + staking: { + /** + * Stash is already bonded. + **/ + AlreadyBonded: AugmentedError; + /** + * Rewards for this era have already been claimed for this validator. + **/ + AlreadyClaimed: AugmentedError; + /** + * Controller is already paired. + **/ + AlreadyPaired: AugmentedError; + /** + * Internal state has become somehow corrupted and the operation cannot continue. + **/ + BadState: AugmentedError; + /** + * A nomination target was supplied that was blocked or otherwise not a validator. + **/ + BadTarget: AugmentedError; + /** + * The user has enough bond and thus cannot be chilled forcefully by an external person. + **/ + CannotChillOther: AugmentedError; + /** + * Commission is too low. Must be at least `MinCommission`. + **/ + CommissionTooLow: AugmentedError; + /** + * Duplicate index. + **/ + DuplicateIndex: AugmentedError; + /** + * Targets cannot be empty. + **/ + EmptyTargets: AugmentedError; + /** + * Attempting to target a stash that still has funds. + **/ + FundedTarget: AugmentedError; + /** + * Incorrect previous history depth input provided. + **/ + IncorrectHistoryDepth: AugmentedError; + /** + * Incorrect number of slashing spans provided. + **/ + IncorrectSlashingSpans: AugmentedError; + /** + * Cannot have a validator or nominator role, with value less than the minimum defined by + * governance (see `MinValidatorBond` and `MinNominatorBond`). If unbonding is the + * intention, `chill` first to remove one's role as validator/nominator. + **/ + InsufficientBond: AugmentedError; + /** + * Invalid era to reward. + **/ + InvalidEraToReward: AugmentedError; + /** + * Invalid number of nominations. + **/ + InvalidNumberOfNominations: AugmentedError; + /** + * Slash record index out of bounds. + **/ + InvalidSlashIndex: AugmentedError; + /** + * Can not schedule more unlock chunks. + **/ + NoMoreChunks: AugmentedError; + /** + * Not a controller account. + **/ + NotController: AugmentedError; + /** + * Items are not sorted and unique. + **/ + NotSortedAndUnique: AugmentedError; + /** + * Not a stash account. + **/ + NotStash: AugmentedError; + /** + * Can not rebond without unlocking chunks. + **/ + NoUnlockChunk: AugmentedError; + /** + * There are too many nominators in the system. Governance needs to adjust the staking + * settings to keep things safe for the runtime. + **/ + TooManyNominators: AugmentedError; + /** + * Too many nomination targets supplied. + **/ + TooManyTargets: AugmentedError; + /** + * There are too many validators in the system. Governance needs to adjust the staking + * settings to keep things safe for the runtime. + **/ + TooManyValidators: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + system: { + /** + * The origin filter prevent the call to be dispatched. + **/ + CallFiltered: AugmentedError; + /** + * Failed to extract the runtime version from the new runtime. + * + * Either calling `Core_version` or decoding `RuntimeVersion` failed. + **/ + FailedToExtractRuntimeVersion: AugmentedError; + /** + * The name of specification does not match between the current runtime + * and the new runtime. + **/ + InvalidSpecName: AugmentedError; + /** + * Suicide called when the account has non-default composite data. + **/ + NonDefaultComposite: AugmentedError; + /** + * There is a non-zero reference count preventing the account from being purged. + **/ + NonZeroRefCount: AugmentedError; + /** + * The specification version is not allowed to decrease between the current runtime + * and the new runtime. + **/ + SpecVersionNeedsToIncrease: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + technicalCommittee: { + /** + * Members are already initialized! + **/ + AlreadyInitialized: AugmentedError; + /** + * Duplicate proposals not allowed + **/ + DuplicateProposal: AugmentedError; + /** + * Duplicate vote ignored + **/ + DuplicateVote: AugmentedError; + /** + * Account is not a member + **/ + NotMember: AugmentedError; + /** + * Proposal must exist + **/ + ProposalMissing: AugmentedError; + /** + * The close call was made too early, before the end of the voting. + **/ + TooEarly: AugmentedError; + /** + * There can only be a maximum of `MaxProposals` active proposals. + **/ + TooManyProposals: AugmentedError; + /** + * Mismatched index + **/ + WrongIndex: AugmentedError; + /** + * The given length bound for the proposal was too low. + **/ + WrongProposalLength: AugmentedError; + /** + * The given weight bound for the proposal was too low. + **/ + WrongProposalWeight: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + technicalMembership: { + /** + * Already a member. + **/ + AlreadyMember: AugmentedError; + /** + * Not a member. + **/ + NotMember: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + tips: { + /** + * The tip was already found/started. + **/ + AlreadyKnown: AugmentedError; + /** + * The account attempting to retract the tip is not the finder of the tip. + **/ + NotFinder: AugmentedError; + /** + * The tip cannot be claimed/closed because it's still in the countdown period. + **/ + Premature: AugmentedError; + /** + * The reason given is just too big. + **/ + ReasonTooBig: AugmentedError; + /** + * The tip cannot be claimed/closed because there are not enough tippers yet. + **/ + StillOpen: AugmentedError; + /** + * The tip hash is unknown. + **/ + UnknownTip: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + treasury: { + /** + * Proposer's balance is too low. + **/ + InsufficientProposersBalance: AugmentedError; + /** + * No proposal or bounty at that index. + **/ + InvalidIndex: AugmentedError; + /** + * Too many approvals in the queue. + **/ + TooManyApprovals: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + ump: { + /** + * The message index given is unknown. + **/ + UnknownMessageIndex: AugmentedError; + /** + * The amount of weight given is possibly not enough for executing the message. + **/ + WeightOverLimit: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + utility: { + /** + * Too many calls batched. + **/ + TooManyCalls: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + vesting: { + /** + * Amount being transferred is too low to create a vesting schedule. + **/ + AmountLow: AugmentedError; + /** + * The account already has `MaxVestingSchedules` count of schedules and thus + * cannot add another one. Consider merging existing schedules in order to add another. + **/ + AtMaxVestingSchedules: AugmentedError; + /** + * Failed to create a new schedule because some parameter was invalid. + **/ + InvalidScheduleParams: AugmentedError; + /** + * The account given is not vesting. + **/ + NotVesting: AugmentedError; + /** + * An index was out of bounds of the vesting schedules. + **/ + ScheduleIndexOutOfBounds: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + xcmPallet: { + /** + * The location is invalid since it already has a subscription from us. + **/ + AlreadySubscribed: AugmentedError; + /** + * The given location could not be used (e.g. because it cannot be expressed in the + * desired version of XCM). + **/ + BadLocation: AugmentedError; + /** + * The version of the `Versioned` value used is not able to be interpreted. + **/ + BadVersion: AugmentedError; + /** + * Could not re-anchor the assets to declare the fees for the destination chain. + **/ + CannotReanchor: AugmentedError; + /** + * The destination `MultiLocation` provided cannot be inverted. + **/ + DestinationNotInvertible: AugmentedError; + /** + * The assets to be sent are empty. + **/ + Empty: AugmentedError; + /** + * The message execution fails the filter. + **/ + Filtered: AugmentedError; + /** + * Origin is invalid for sending. + **/ + InvalidOrigin: AugmentedError; + /** + * The referenced subscription could not be found. + **/ + NoSubscription: AugmentedError; + /** + * 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: AugmentedError; + /** + * Too many assets have been attempted for transfer. + **/ + TooManyAssets: AugmentedError; + /** + * The desired destination was unreachable, generally because there is a no way of routing + * to it. + **/ + Unreachable: AugmentedError; + /** + * The message's weight could not be determined. + **/ + UnweighableMessage: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + } // AugmentedErrors +} // declare module diff --git a/packages/api-augment/src/kusama/events.ts b/packages/api-augment/src/kusama/events.ts new file mode 100644 index 0000000000..c9001899f4 --- /dev/null +++ b/packages/api-augment/src/kusama/events.ts @@ -0,0 +1,1282 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; +import type { Bytes, Null, Option, Result, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { ITuple } from '@polkadot/types-codec/types'; +import type { EthereumAddress } from '@polkadot/types/interfaces/eth'; +import type { AccountId32, H256 } from '@polkadot/types/interfaces/runtime'; +import type { FrameSupportScheduleLookupError, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchInfo, KusamaRuntimeProxyType, PalletDemocracyVoteAccountVote, PalletDemocracyVoteThreshold, PalletElectionProviderMultiPhaseElectionCompute, PalletImOnlineSr25519AppSr25519Public, PalletMultisigTimepoint, PalletStakingExposure, PolkadotParachainPrimitivesHrmpChannelId, PolkadotPrimitivesV1CandidateReceipt, PolkadotRuntimeParachainsDisputesDisputeLocation, PolkadotRuntimeParachainsDisputesDisputeResult, SpFinalityGrandpaAppPublic, SpRuntimeDispatchError, XcmV1MultiLocation, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation } from '@polkadot/types/lookup'; + +declare module '@polkadot/api-base/types/events' { + export interface AugmentedEvents { + auctions: { + /** + * An auction ended. All funds become unreserved. `[auction_index]` + **/ + AuctionClosed: AugmentedEvent; + /** + * An auction started. Provides its index and the block number where it will begin to + * close and the first lease period of the quadruplet that is auctioned. + * `[auction_index, lease_period, ending]` + **/ + AuctionStarted: AugmentedEvent; + /** + * A new bid has been accepted as the current winner. + * `[who, para_id, amount, first_slot, last_slot]` + **/ + BidAccepted: AugmentedEvent; + /** + * Someone attempted to lease the same slot twice for a parachain. The amount is held in reserve + * but no parachain slot has been leased. + * `[parachain_id, leaser, amount]` + **/ + ReserveConfiscated: AugmentedEvent; + /** + * Funds were reserved for a winning bid. First balance is the extra amount reserved. + * Second is the total. `[bidder, extra_reserved, total_amount]` + **/ + Reserved: AugmentedEvent; + /** + * Funds were unreserved since bidder is no longer active. `[bidder, amount]` + **/ + Unreserved: AugmentedEvent; + /** + * The winning offset was chosen for an auction. This will map into the `Winning` storage map. + * `[auction_index, block_number]` + **/ + WinningOffset: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + bagsList: { + /** + * Moved an account from one bag to another. + **/ + Rebagged: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + balances: { + /** + * A balance was set by root. + **/ + BalanceSet: AugmentedEvent; + /** + * Some amount was deposited (e.g. for transaction fees). + **/ + Deposit: AugmentedEvent; + /** + * An account was removed whose balance was non-zero but below ExistentialDeposit, + * resulting in an outright loss. + **/ + DustLost: AugmentedEvent; + /** + * An account was created with some free balance. + **/ + Endowed: AugmentedEvent; + /** + * Some balance was reserved (moved from free to reserved). + **/ + Reserved: AugmentedEvent; + /** + * Some balance was moved from the reserve of the first account to the second account. + * Final argument indicates the destination balance type. + **/ + ReserveRepatriated: AugmentedEvent; + /** + * Some amount was removed from the account (e.g. for misbehavior). + **/ + Slashed: AugmentedEvent; + /** + * Transfer succeeded. + **/ + Transfer: AugmentedEvent; + /** + * Some balance was unreserved (moved from reserved to free). + **/ + Unreserved: AugmentedEvent; + /** + * Some amount was withdrawn from the account (e.g. for transaction fees). + **/ + Withdraw: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + bounties: { + /** + * A bounty is awarded to a beneficiary. + **/ + BountyAwarded: AugmentedEvent; + /** + * A bounty proposal is funded and became active. + **/ + BountyBecameActive: AugmentedEvent; + /** + * A bounty is cancelled. + **/ + BountyCanceled: AugmentedEvent; + /** + * A bounty is claimed by beneficiary. + **/ + BountyClaimed: AugmentedEvent; + /** + * A bounty expiry is extended. + **/ + BountyExtended: AugmentedEvent; + /** + * New bounty proposal. + **/ + BountyProposed: AugmentedEvent; + /** + * A bounty proposal was rejected; funds were slashed. + **/ + BountyRejected: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + claims: { + /** + * Someone claimed some DOTs. `[who, ethereum_address, amount]` + **/ + Claimed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + council: { + /** + * A motion was approved by the required threshold. + **/ + Approved: AugmentedEvent; + /** + * A proposal was closed because its threshold was reached or after its duration was up. + **/ + Closed: AugmentedEvent; + /** + * A motion was not approved by the required threshold. + **/ + Disapproved: AugmentedEvent; + /** + * A motion was executed; result will be `Ok` if it returned without error. + **/ + Executed: AugmentedEvent]>; + /** + * A single member did some action; result will be `Ok` if it returned without error. + **/ + MemberExecuted: AugmentedEvent]>; + /** + * A motion (given hash) has been proposed (by given account) with a threshold (given + * `MemberCount`). + **/ + Proposed: AugmentedEvent; + /** + * A motion (given hash) has been voted on by given account, leaving + * a tally (yes votes and no votes given respectively as `MemberCount`). + **/ + Voted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + crowdloan: { + /** + * A parachain has been moved to `NewRaise` + **/ + AddedToNewRaise: AugmentedEvent; + /** + * All loans in a fund have been refunded. `[fund_index]` + **/ + AllRefunded: AugmentedEvent; + /** + * Contributed to a crowd sale. `[who, fund_index, amount]` + **/ + Contributed: AugmentedEvent; + /** + * Create a new crowdloaning campaign. `[fund_index]` + **/ + Created: AugmentedEvent; + /** + * Fund is dissolved. `[fund_index]` + **/ + Dissolved: AugmentedEvent; + /** + * The configuration to a crowdloan has been edited. `[fund_index]` + **/ + Edited: AugmentedEvent; + /** + * The result of trying to submit a new bid to the Slots pallet. + **/ + HandleBidResult: AugmentedEvent]>; + /** + * A memo has been updated. `[who, fund_index, memo]` + **/ + MemoUpdated: AugmentedEvent; + /** + * The loans in a fund have been partially dissolved, i.e. there are some left + * over child keys that still need to be killed. `[fund_index]` + **/ + PartiallyRefunded: AugmentedEvent; + /** + * Withdrew full balance of a contributor. `[who, fund_index, amount]` + **/ + Withdrew: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + democracy: { + /** + * A proposal_hash has been blacklisted permanently. + **/ + Blacklisted: AugmentedEvent; + /** + * A referendum has been cancelled. + **/ + Cancelled: AugmentedEvent; + /** + * An account has delegated their vote to another account. + **/ + Delegated: AugmentedEvent; + /** + * A proposal has been enacted. + **/ + Executed: AugmentedEvent]>; + /** + * An external proposal has been tabled. + **/ + ExternalTabled: AugmentedEvent; + /** + * A proposal has been rejected by referendum. + **/ + NotPassed: AugmentedEvent; + /** + * A proposal has been approved by referendum. + **/ + Passed: AugmentedEvent; + /** + * A proposal could not be executed because its preimage was invalid. + **/ + PreimageInvalid: AugmentedEvent; + /** + * A proposal could not be executed because its preimage was missing. + **/ + PreimageMissing: AugmentedEvent; + /** + * A proposal's preimage was noted, and the deposit taken. + **/ + PreimageNoted: AugmentedEvent; + /** + * A registered preimage was removed and the deposit collected by the reaper. + **/ + PreimageReaped: AugmentedEvent; + /** + * A proposal preimage was removed and used (the deposit was returned). + **/ + PreimageUsed: AugmentedEvent; + /** + * A motion has been proposed by a public account. + **/ + Proposed: AugmentedEvent; + /** + * An account has secconded a proposal + **/ + Seconded: AugmentedEvent; + /** + * A referendum has begun. + **/ + Started: AugmentedEvent; + /** + * A public proposal has been tabled for referendum vote. + **/ + Tabled: AugmentedEvent]>; + /** + * An account has cancelled a previous delegation operation. + **/ + Undelegated: AugmentedEvent; + /** + * An external proposal has been vetoed. + **/ + Vetoed: AugmentedEvent; + /** + * An account has voted in a referendum + **/ + Voted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + electionProviderMultiPhase: { + /** + * The election has been finalized, with `Some` of the given computation, or else if the + * election failed, `None`. + **/ + ElectionFinalized: AugmentedEvent]>; + /** + * An account has been rewarded for their signed submission being finalized. + **/ + Rewarded: AugmentedEvent; + /** + * The signed phase of the given round has started. + **/ + SignedPhaseStarted: AugmentedEvent; + /** + * An account has been slashed for submitting an invalid signed submission. + **/ + Slashed: AugmentedEvent; + /** + * A solution was stored with the given compute. + * + * If the solution is signed, this means that it hasn't yet been processed. If the + * solution is unsigned, this means that it has also been processed. + * + * The `bool` is `true` when a previous solution was ejected to make room for this one. + **/ + SolutionStored: AugmentedEvent; + /** + * The unsigned phase of the given round has started. + **/ + UnsignedPhaseStarted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + gilt: { + /** + * A bid was successfully placed. + **/ + BidPlaced: AugmentedEvent; + /** + * A bid was successfully removed (before being accepted as a gilt). + **/ + BidRetracted: AugmentedEvent; + /** + * A bid was accepted as a gilt. The balance may not be released until expiry. + **/ + GiltIssued: AugmentedEvent; + /** + * An expired gilt has been thawed. + **/ + GiltThawed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + grandpa: { + /** + * New authority set has been applied. + **/ + NewAuthorities: AugmentedEvent>]>; + /** + * Current authority set has been paused. + **/ + Paused: AugmentedEvent; + /** + * Current authority set has been resumed. + **/ + Resumed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + hrmp: { + /** + * HRMP channel closed. `[by_parachain, channel_id]` + **/ + ChannelClosed: AugmentedEvent; + /** + * Open HRMP channel accepted. `[sender, recipient]` + **/ + OpenChannelAccepted: AugmentedEvent; + /** + * An HRMP channel request sent by the receiver was canceled by either party. + * `[by_parachain, channel_id]` + **/ + OpenChannelCanceled: AugmentedEvent; + /** + * Open HRMP channel requested. + * `[sender, recipient, proposed_max_capacity, proposed_max_message_size]` + **/ + OpenChannelRequested: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + identity: { + /** + * A name was cleared, and the given balance returned. + **/ + IdentityCleared: AugmentedEvent; + /** + * A name was removed and the given balance slashed. + **/ + IdentityKilled: AugmentedEvent; + /** + * A name was set or reset (which will remove all judgements). + **/ + IdentitySet: AugmentedEvent; + /** + * A judgement was given by a registrar. + **/ + JudgementGiven: AugmentedEvent; + /** + * A judgement was asked from a registrar. + **/ + JudgementRequested: AugmentedEvent; + /** + * A judgement request was retracted. + **/ + JudgementUnrequested: AugmentedEvent; + /** + * A registrar was added. + **/ + RegistrarAdded: AugmentedEvent; + /** + * A sub-identity was added to an identity and the deposit paid. + **/ + SubIdentityAdded: AugmentedEvent; + /** + * A sub-identity was removed from an identity and the deposit freed. + **/ + SubIdentityRemoved: AugmentedEvent; + /** + * A sub-identity was cleared, and the given deposit repatriated from the + * main identity account to the sub-identity account. + **/ + SubIdentityRevoked: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + imOnline: { + /** + * At the end of the session, no offence was committed. + **/ + AllGood: AugmentedEvent; + /** + * A new heartbeat was received from `AuthorityId`. + **/ + HeartbeatReceived: AugmentedEvent; + /** + * At the end of the session, at least one validator was found to be offline. + **/ + SomeOffline: AugmentedEvent>]>; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + indices: { + /** + * A account index was assigned. + **/ + IndexAssigned: AugmentedEvent; + /** + * A account index has been freed up (unassigned). + **/ + IndexFreed: AugmentedEvent; + /** + * A account index has been frozen to its current account ID. + **/ + IndexFrozen: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + multisig: { + /** + * A multisig operation has been approved by someone. + **/ + MultisigApproval: AugmentedEvent; + /** + * A multisig operation has been cancelled. + **/ + MultisigCancelled: AugmentedEvent; + /** + * A multisig operation has been executed. + **/ + MultisigExecuted: AugmentedEvent]>; + /** + * A new multisig operation has begun. + **/ + NewMultisig: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + offences: { + /** + * There is an offence reported of the given `kind` happened at the `session_index` and + * (kind-specific) time slot. This event is not deposited for duplicate slashes. + * \[kind, timeslot\]. + **/ + Offence: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + paraInclusion: { + /** + * A candidate was backed. `[candidate, head_data]` + **/ + CandidateBacked: AugmentedEvent; + /** + * A candidate was included. `[candidate, head_data]` + **/ + CandidateIncluded: AugmentedEvent; + /** + * A candidate timed out. `[candidate, head_data]` + **/ + CandidateTimedOut: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + paras: { + /** + * A para has been queued to execute pending actions. `para_id` + **/ + ActionQueued: AugmentedEvent; + /** + * A code upgrade has been scheduled for a Para. `para_id` + **/ + CodeUpgradeScheduled: AugmentedEvent; + /** + * Current code has been updated for a Para. `para_id` + **/ + CurrentCodeUpdated: AugmentedEvent; + /** + * Current head has been updated for a Para. `para_id` + **/ + CurrentHeadUpdated: AugmentedEvent; + /** + * A new head has been noted for a Para. `para_id` + **/ + NewHeadNoted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + parasDisputes: { + /** + * A dispute has concluded for or against a candidate. + * `\[para id, candidate hash, dispute result\]` + **/ + DisputeConcluded: AugmentedEvent; + /** + * A dispute has been initiated. \[candidate hash, dispute location\] + **/ + DisputeInitiated: AugmentedEvent; + /** + * A dispute has timed out due to insufficient participation. + * `\[para id, candidate hash\]` + **/ + DisputeTimedOut: AugmentedEvent; + /** + * A dispute has concluded with supermajority against a candidate. + * Block authors should no longer build on top of this head and should + * instead revert the block at the given height. This should be the + * number of the child of the last known valid block in the chain. + **/ + Revert: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + phragmenElection: { + /** + * A candidate was slashed by amount due to failing to obtain a seat as member or + * runner-up. + * + * Note that old members and runners-up are also candidates. + **/ + CandidateSlashed: AugmentedEvent; + /** + * Internal error happened while trying to perform election. + **/ + ElectionError: AugmentedEvent; + /** + * No (or not enough) candidates existed for this round. This is different from + * `NewTerm(\[\])`. See the description of `NewTerm`. + **/ + EmptyTerm: AugmentedEvent; + /** + * A member has been removed. This should always be followed by either `NewTerm` or + * `EmptyTerm`. + **/ + MemberKicked: AugmentedEvent; + /** + * A new term with new_members. This indicates that enough candidates existed to run + * the election, not that enough have has been elected. The inner value must be examined + * for this purpose. A `NewTerm(\[\])` indicates that some candidates got their bond + * slashed and none were elected, whilst `EmptyTerm` means that no candidates existed to + * begin with. + **/ + NewTerm: AugmentedEvent>]>; + /** + * Someone has renounced their candidacy. + **/ + Renounced: AugmentedEvent; + /** + * A seat holder was slashed by amount by being forcefully removed from the set. + **/ + SeatHolderSlashed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + preimage: { + /** + * A preimage has ben cleared. + **/ + Cleared: AugmentedEvent; + /** + * A preimage has been noted. + **/ + Noted: AugmentedEvent; + /** + * A preimage has been requested. + **/ + Requested: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + proxy: { + /** + * An announcement was placed to make a call in the future. + **/ + Announced: AugmentedEvent; + /** + * Anonymous account has been created by new proxy with given + * disambiguation index and proxy type. + **/ + AnonymousCreated: AugmentedEvent; + /** + * A proxy was added. + **/ + ProxyAdded: AugmentedEvent; + /** + * A proxy was executed correctly, with the given. + **/ + ProxyExecuted: AugmentedEvent]>; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + recovery: { + /** + * Lost account has been successfully recovered by rescuer account. + **/ + AccountRecovered: AugmentedEvent; + /** + * A recovery process for lost account by rescuer account has been closed. + **/ + RecoveryClosed: AugmentedEvent; + /** + * A recovery process has been set up for an account. + **/ + RecoveryCreated: AugmentedEvent; + /** + * A recovery process has been initiated for lost account by rescuer account. + **/ + RecoveryInitiated: AugmentedEvent; + /** + * A recovery process has been removed for an account. + **/ + RecoveryRemoved: AugmentedEvent; + /** + * A recovery process for lost account by rescuer account has been vouched for by sender. + **/ + RecoveryVouched: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + registrar: { + Deregistered: AugmentedEvent; + Registered: AugmentedEvent; + Reserved: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + scheduler: { + /** + * The call for the provided hash was not found so the task has been aborted. + **/ + CallLookupFailed: AugmentedEvent, Option, FrameSupportScheduleLookupError]>; + /** + * Canceled some task. + **/ + Canceled: AugmentedEvent; + /** + * Dispatched some task. + **/ + Dispatched: AugmentedEvent, Option, Result]>; + /** + * Scheduled some task. + **/ + Scheduled: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + session: { + /** + * New session has happened. Note that the argument is the session index, not the + * block number as the type might suggest. + **/ + NewSession: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + slots: { + /** + * A para has won the right to a continuous set of lease periods as a parachain. + * First balance is any extra amount reserved on top of the para's existing deposit. + * Second balance is the total amount reserved. + * `[parachain_id, leaser, period_begin, period_count, extra_reserved, total_amount]` + **/ + Leased: AugmentedEvent; + /** + * A new `[lease_period]` is beginning. + **/ + NewLeasePeriod: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + society: { + /** + * A candidate was dropped (due to an excess of bids in the system). + **/ + AutoUnbid: AugmentedEvent; + /** + * A membership bid just happened. The given account is the candidate's ID and their offer + * is the second. + **/ + Bid: AugmentedEvent; + /** + * A candidate has been suspended + **/ + CandidateSuspended: AugmentedEvent; + /** + * A member has been challenged + **/ + Challenged: AugmentedEvent; + /** + * A vote has been placed for a defending member + **/ + DefenderVote: AugmentedEvent; + /** + * Some funds were deposited into the society account. + **/ + Deposit: AugmentedEvent; + /** + * The society is founded by the given identity. + **/ + Founded: AugmentedEvent; + /** + * A group of candidates have been inducted. The batch's primary is the first value, the + * batch in full is the second. + **/ + Inducted: AugmentedEvent]>; + /** + * A member has been suspended + **/ + MemberSuspended: AugmentedEvent; + /** + * A new \[max\] member count has been set + **/ + NewMaxMembers: AugmentedEvent; + /** + * A suspended member has been judged. + **/ + SuspendedMemberJudgement: AugmentedEvent; + /** + * A candidate was dropped (by their request). + **/ + Unbid: AugmentedEvent; + /** + * Society is unfounded. + **/ + Unfounded: AugmentedEvent; + /** + * A candidate was dropped (by request of who vouched for them). + **/ + Unvouch: AugmentedEvent; + /** + * A vote has been placed + **/ + Vote: AugmentedEvent; + /** + * A membership bid just happened by vouching. The given account is the candidate's ID and + * their offer is the second. The vouching party is the third. + **/ + Vouch: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + staking: { + /** + * An account has bonded this amount. \[stash, amount\] + * + * NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably, + * it will not be emitted for staking rewards when they are added to stake. + **/ + Bonded: AugmentedEvent; + /** + * An account has stopped participating as either a validator or nominator. + * \[stash\] + **/ + Chilled: AugmentedEvent; + /** + * The era payout has been set; the first balance is the validator-payout; the second is + * the remainder from the maximum amount of reward. + * \[era_index, validator_payout, remainder\] + **/ + EraPaid: AugmentedEvent; + /** + * A nominator has been kicked from a validator. \[nominator, stash\] + **/ + Kicked: AugmentedEvent; + /** + * An old slashing report from a prior era was discarded because it could + * not be processed. \[session_index\] + **/ + OldSlashingReportDiscarded: AugmentedEvent; + /** + * The stakers' rewards are getting paid. \[era_index, validator_stash\] + **/ + PayoutStarted: AugmentedEvent; + /** + * The nominator has been rewarded by this amount. \[stash, amount\] + **/ + Rewarded: AugmentedEvent; + /** + * One validator (and its nominators) has been slashed by the given amount. + * \[validator, amount\] + **/ + Slashed: AugmentedEvent; + /** + * A new set of stakers was elected. + **/ + StakersElected: AugmentedEvent; + /** + * The election failed. No new era is planned. + **/ + StakingElectionFailed: AugmentedEvent; + /** + * An account has unbonded this amount. \[stash, amount\] + **/ + Unbonded: AugmentedEvent; + /** + * An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance` + * from the unlocking queue. \[stash, amount\] + **/ + Withdrawn: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + system: { + /** + * `:code` was updated. + **/ + CodeUpdated: AugmentedEvent; + /** + * An extrinsic failed. + **/ + ExtrinsicFailed: AugmentedEvent; + /** + * An extrinsic completed successfully. + **/ + ExtrinsicSuccess: AugmentedEvent; + /** + * An account was reaped. + **/ + KilledAccount: AugmentedEvent; + /** + * A new account was created. + **/ + NewAccount: AugmentedEvent; + /** + * On on-chain remark happened. + **/ + Remarked: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + technicalCommittee: { + /** + * A motion was approved by the required threshold. + **/ + Approved: AugmentedEvent; + /** + * A proposal was closed because its threshold was reached or after its duration was up. + **/ + Closed: AugmentedEvent; + /** + * A motion was not approved by the required threshold. + **/ + Disapproved: AugmentedEvent; + /** + * A motion was executed; result will be `Ok` if it returned without error. + **/ + Executed: AugmentedEvent]>; + /** + * A single member did some action; result will be `Ok` if it returned without error. + **/ + MemberExecuted: AugmentedEvent]>; + /** + * A motion (given hash) has been proposed (by given account) with a threshold (given + * `MemberCount`). + **/ + Proposed: AugmentedEvent; + /** + * A motion (given hash) has been voted on by given account, leaving + * a tally (yes votes and no votes given respectively as `MemberCount`). + **/ + Voted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + technicalMembership: { + /** + * Phantom member, never used. + **/ + Dummy: AugmentedEvent; + /** + * One of the members' keys changed. + **/ + KeyChanged: AugmentedEvent; + /** + * The given member was added; see the transaction for who. + **/ + MemberAdded: AugmentedEvent; + /** + * The given member was removed; see the transaction for who. + **/ + MemberRemoved: AugmentedEvent; + /** + * The membership was reset; see the transaction for who the new set is. + **/ + MembersReset: AugmentedEvent; + /** + * Two members were swapped; see the transaction for who. + **/ + MembersSwapped: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + tips: { + /** + * A new tip suggestion has been opened. + **/ + NewTip: AugmentedEvent; + /** + * A tip suggestion has been closed. + **/ + TipClosed: AugmentedEvent; + /** + * A tip suggestion has reached threshold and is closing. + **/ + TipClosing: AugmentedEvent; + /** + * A tip suggestion has been retracted. + **/ + TipRetracted: AugmentedEvent; + /** + * A tip suggestion has been slashed. + **/ + TipSlashed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + treasury: { + /** + * Some funds have been allocated. + **/ + Awarded: AugmentedEvent; + /** + * Some of our funds have been burnt. + **/ + Burnt: AugmentedEvent; + /** + * Some funds have been deposited. + **/ + Deposit: AugmentedEvent; + /** + * New proposal. + **/ + Proposed: AugmentedEvent; + /** + * A proposal was rejected; funds were slashed. + **/ + Rejected: AugmentedEvent; + /** + * Spending has finished; this is the amount that rolls over until next spend. + **/ + Rollover: AugmentedEvent; + /** + * We have ended a spend period and will now allocate funds. + **/ + Spending: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + ump: { + /** + * Upward message executed with the given outcome. + * \[ id, outcome \] + **/ + ExecutedUpward: AugmentedEvent; + /** + * Upward message is invalid XCM. + * \[ id \] + **/ + InvalidFormat: AugmentedEvent; + /** + * The weight budget was exceeded for an individual upward message. + * + * This message can be later dispatched manually using `service_overweight` dispatchable + * using the assigned `overweight_index`. + * + * \[ para, id, overweight_index, required \] + **/ + OverweightEnqueued: AugmentedEvent; + /** + * Upward message from the overweight queue was executed with the given actual weight + * used. + * + * \[ overweight_index, used \] + **/ + OverweightServiced: AugmentedEvent; + /** + * Upward message is unsupported version of XCM. + * \[ id \] + **/ + UnsupportedVersion: AugmentedEvent; + /** + * Some upward messages have been received and will be processed. + * \[ para, count, size \] + **/ + UpwardMessagesReceived: AugmentedEvent; + /** + * The weight limit for handling upward messages was reached. + * \[ id, remaining, required \] + **/ + WeightExhausted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + utility: { + /** + * Batch of dispatches completed fully with no error. + **/ + BatchCompleted: AugmentedEvent; + /** + * Batch of dispatches did not complete fully. Index of first failing dispatch given, as + * well as the error. + **/ + BatchInterrupted: AugmentedEvent; + /** + * A call was dispatched. + **/ + DispatchedAs: AugmentedEvent]>; + /** + * A single item within a Batch of dispatches has completed with no error. + **/ + ItemCompleted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + vesting: { + /** + * An \[account\] has become fully vested. + **/ + VestingCompleted: AugmentedEvent; + /** + * The amount vested has been updated. This could indicate a change in funds available. + * The balance given is the amount which is left unvested (and thus locked). + **/ + VestingUpdated: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + xcmPallet: { + /** + * Some assets have been placed in an asset trap. + * + * \[ hash, origin, assets \] + **/ + AssetsTrapped: AugmentedEvent; + /** + * Execution of an XCM message was attempted. + * + * \[ outcome \] + **/ + Attempted: AugmentedEvent; + /** + * Expected query response has been received but the origin location of the response does + * not match that expected. The query remains registered for a later, valid, response to + * be received and acted upon. + * + * \[ origin location, id, expected location \] + **/ + InvalidResponder: AugmentedEvent]>; + /** + * Expected query response has been received but the expected origin location placed in + * storage by this runtime previously cannot be decoded. The query remains registered. + * + * This is unexpected (since a location placed in storage in a previously executing + * runtime should be readable prior to query timeout) and dangerous since the possibly + * valid response will be dropped. Manual governance intervention is probably going to be + * needed. + * + * \[ origin location, id \] + **/ + InvalidResponderVersion: AugmentedEvent; + /** + * Query response has been received and query is removed. The registered notification has + * been dispatched and executed successfully. + * + * \[ id, pallet index, call index \] + **/ + Notified: AugmentedEvent; + /** + * Query response has been received and query is removed. The dispatch was unable to be + * decoded into a `Call`; this might be due to dispatch function having a signature which + * is not `(origin, QueryId, Response)`. + * + * \[ id, pallet index, call index \] + **/ + NotifyDecodeFailed: AugmentedEvent; + /** + * Query response has been received and query is removed. There was a general error with + * dispatching the notification call. + * + * \[ id, pallet index, call index \] + **/ + NotifyDispatchError: AugmentedEvent; + /** + * Query response has been received and query is removed. The registered notification could + * not be dispatched because the dispatch weight is greater than the maximum weight + * originally budgeted by this runtime for the query result. + * + * \[ id, pallet index, call index, actual weight, max budgeted weight \] + **/ + NotifyOverweight: AugmentedEvent; + /** + * A given location which had a version change subscription was dropped owing to an error + * migrating the location to our new XCM format. + * + * \[ location, query ID \] + **/ + NotifyTargetMigrationFail: AugmentedEvent; + /** + * A given location which had a version change subscription was dropped owing to an error + * sending the notification to it. + * + * \[ location, query ID, error \] + **/ + NotifyTargetSendFail: AugmentedEvent; + /** + * Query response has been received and is ready for taking with `take_response`. There is + * no registered notification call. + * + * \[ id, response \] + **/ + ResponseReady: AugmentedEvent; + /** + * Received query response has been read and removed. + * + * \[ id \] + **/ + ResponseTaken: AugmentedEvent; + /** + * A XCM message was sent. + * + * \[ origin, destination, message \] + **/ + Sent: AugmentedEvent; + /** + * The supported version of a location has been changed. This might be through an + * automatic notification or a manual intervention. + * + * \[ location, XCM version \] + **/ + SupportedVersionChanged: AugmentedEvent; + /** + * Query response received which does not match a registered query. This may be because a + * matching query was never registered, it may be because it is a duplicate response, or + * because the query timed out. + * + * \[ origin location, id \] + **/ + UnexpectedResponse: AugmentedEvent; + /** + * An XCM version change notification message has been attempted to be sent. + * + * \[ destination, result \] + **/ + VersionChangeNotified: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + } // AugmentedEvents +} // declare module diff --git a/packages/api-augment/src/kusama/index.ts b/packages/api-augment/src/kusama/index.ts new file mode 100644 index 0000000000..54df49bcd9 --- /dev/null +++ b/packages/api-augment/src/kusama/index.ts @@ -0,0 +1,9 @@ +// Copyright 2017-2021 @polkadot/api-augment authors & contributors +// SPDX-License-Identifier: Apache-2.0 + +import '../base'; +import './consts'; +import './errors'; +import './events'; +import './query'; +import './tx'; diff --git a/packages/api-augment/src/kusama/query.ts b/packages/api-augment/src/kusama/query.ts new file mode 100644 index 0000000000..e5e8cec025 --- /dev/null +++ b/packages/api-augment/src/kusama/query.ts @@ -0,0 +1,1893 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; +import type { Data } from '@polkadot/types'; +import type { BTreeMap, Bytes, Null, Option, U8aFixed, Vec, WrapperOpaque, bool, u128, u32, u64 } from '@polkadot/types-codec'; +import type { AnyNumber, ITuple } from '@polkadot/types-codec/types'; +import type { EthereumAddress } from '@polkadot/types/interfaces/eth'; +import type { AccountId32, Call, H256, Perbill, Percent } from '@polkadot/types/interfaces/runtime'; +import type { FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, KusamaRuntimeSessionKeys, PalletAuthorshipUncleEntryItem, PalletBagsListListBag, PalletBagsListListNode, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletBountiesBounty, PalletCollectiveVotes, PalletDemocracyPreimageStatus, PalletDemocracyReferendumInfo, PalletDemocracyReleases, PalletDemocracyVoteThreshold, PalletDemocracyVoteVoting, PalletElectionProviderMultiPhasePhase, PalletElectionProviderMultiPhaseReadySolution, PalletElectionProviderMultiPhaseRoundSnapshot, PalletElectionProviderMultiPhaseSignedSignedSubmission, PalletElectionProviderMultiPhaseSolutionOrSnapshotSize, PalletElectionsPhragmenSeatHolder, PalletElectionsPhragmenVoter, PalletGiltActiveGilt, PalletGiltActiveGiltsTotal, PalletGiltGiltBid, PalletGrandpaStoredPendingChange, PalletGrandpaStoredState, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletImOnlineBoundedOpaqueNetworkState, PalletImOnlineSr25519AppSr25519Public, PalletMultisigMultisig, PalletPreimageRequestStatus, PalletProxyAnnouncement, PalletProxyProxyDefinition, PalletRecoveryActiveRecovery, PalletRecoveryRecoveryConfig, PalletSchedulerReleases, PalletSchedulerScheduledV3, PalletSocietyBid, PalletSocietyBidKind, PalletSocietyVote, PalletSocietyVouchingStatus, PalletStakingActiveEraInfo, PalletStakingEraRewardPoints, PalletStakingExposure, PalletStakingForcing, PalletStakingNominations, PalletStakingReleases, PalletStakingRewardDestination, PalletStakingSlashingSlashingSpans, PalletStakingSlashingSpanRecord, PalletStakingStakingLedger, PalletStakingUnappliedSlash, PalletStakingValidatorPrefs, PalletTipsOpenTip, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletVestingReleases, PalletVestingVestingInfo, PalletXcmQueryStatus, PalletXcmVersionMigrationStage, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotParachainPrimitivesHrmpChannelId, PolkadotPrimitivesV0ValidatorAppPublic, PolkadotPrimitivesV1AssignmentAppPublic, PolkadotPrimitivesV1CandidateCommitments, PolkadotPrimitivesV1CoreOccupied, PolkadotPrimitivesV1DisputeState, PolkadotPrimitivesV1ScrapedOnChainVotes, PolkadotPrimitivesV1SessionInfo, PolkadotPrimitivesV1UpgradeGoAhead, PolkadotPrimitivesV1UpgradeRestriction, PolkadotRuntimeCommonClaimsStatementKind, PolkadotRuntimeCommonCrowdloanFundInfo, PolkadotRuntimeCommonParasRegistrarParaInfo, PolkadotRuntimeParachainsConfigurationHostConfiguration, PolkadotRuntimeParachainsHrmpHrmpChannel, PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest, PolkadotRuntimeParachainsInclusionAvailabilityBitfieldRecord, PolkadotRuntimeParachainsInclusionCandidatePendingAvailability, PolkadotRuntimeParachainsInitializerBufferedSessionChange, PolkadotRuntimeParachainsParasParaGenesisArgs, PolkadotRuntimeParachainsParasParaLifecycle, PolkadotRuntimeParachainsParasParaPastCodeMeta, PolkadotRuntimeParachainsParasPvfCheckActiveVoteState, PolkadotRuntimeParachainsSchedulerCoreAssignment, PolkadotRuntimeParachainsSchedulerParathreadClaimQueue, SpConsensusBabeAppPublic, SpConsensusBabeBabeEpochConfiguration, SpConsensusBabeDigestsNextConfigDescriptor, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpStakingOffenceOffenceDetails, XcmVersionedMultiLocation } from '@polkadot/types/lookup'; +import type { Observable } from '@polkadot/types/types'; + +declare module '@polkadot/api-base/types/storage' { + export interface AugmentedQueries { + auctions: { + /** + * Number of auctions started so far. + **/ + auctionCounter: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Information relating to the current auction, if there is one. + * + * The first item in the tuple is the lease period index that the first of the four + * contiguous lease periods on auction is for. The second is the block number when the + * auction will "begin to end", i.e. the first block of the Ending Period of the auction. + **/ + auctionInfo: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Amounts currently reserved in the accounts of the bidders currently winning + * (sub-)ranges. + **/ + reservedAmounts: AugmentedQuery | [AccountId32 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable>, [ITuple<[AccountId32, u32]>]> & QueryableStorageEntry]>; + /** + * The winning bids for each of the 10 ranges at each sample in the final Ending Period of + * the current auction. The map's key is the 0-based index into the Sample Size. The + * first sample of the ending period is 0; the last is `Sample Size - 1`. + **/ + winning: AugmentedQuery Observable>>>>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + authorship: { + /** + * Author of current block. + **/ + author: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Whether uncles were already set in this block. + **/ + didSetUncles: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Uncles + **/ + uncles: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + babe: { + /** + * Current epoch authorities. + **/ + authorities: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * This field should always be populated during block processing unless + * secondary plain slots are enabled (which don't contain a VRF output). + * + * It is set in `on_initialize`, before it will contain the value from the last block. + **/ + authorVrfRandomness: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Current slot number. + **/ + currentSlot: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The configuration for the current epoch. Should never be `None` as it is initialized in + * genesis. + **/ + epochConfig: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Current epoch index. + **/ + epochIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The block numbers when the last and current epoch have started, respectively `N-1` and + * `N`. + * NOTE: We track this is in order to annotate the block number when a given pool of + * entropy was fixed (i.e. it was known to chain observers). Since epochs are defined in + * slots, which may be skipped, the block numbers may not line up with the slot numbers. + **/ + epochStart: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The slot at which the first epoch actually started. This is 0 + * until the first block of the chain. + **/ + genesisSlot: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Temporary value (cleared at block finalization) which is `Some` + * if per-block initialization has already been called for current block. + **/ + initialized: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * How late the current block is compared to its parent. + * + * This entry is populated as part of block execution and is cleaned up + * on block finalization. Querying this storage entry outside of block + * execution context should always yield zero. + **/ + lateness: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Next epoch authorities. + **/ + nextAuthorities: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The configuration for the next epoch, `None` if the config will not change + * (you can fallback to `EpochConfig` instead in that case). + **/ + nextEpochConfig: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Next epoch randomness. + **/ + nextRandomness: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Pending epoch configuration change that will be applied when the next epoch is enacted. + **/ + pendingEpochConfigChange: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The epoch randomness for the *current* epoch. + * + * # Security + * + * This MUST NOT be used for gambling, as it can be influenced by a + * malicious validator in the short term. It MAY be used in many + * cryptographic protocols, however, so long as one remembers that this + * (like everything else on-chain) it is public. For example, it can be + * used where a number is needed that cannot have been chosen by an + * adversary, for purposes such as public-coin zero-knowledge proofs. + **/ + randomness: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Randomness under construction. + * + * We make a trade-off between storage accesses and list length. + * We store the under-construction randomness in segments of up to + * `UNDER_CONSTRUCTION_SEGMENT_LENGTH`. + * + * Once a segment reaches this length, we begin the next one. + * We reset all segments and return to `0` at the beginning of every + * epoch. + **/ + segmentIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay. + **/ + underConstruction: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + bagsList: { + /** + * Counter for the related counted storage map + **/ + counterForListNodes: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * A bag stored in storage. + * + * Stores a `Bag` struct, which stores head and tail pointers to itself. + **/ + listBags: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + /** + * A single node, within some bag. + * + * Nodes store links forward and back within their respective bags. + **/ + listNodes: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + balances: { + /** + * The balance of an account. + * + * NOTE: This is only used in the case that this pallet is used to store balances. + **/ + account: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Any liquidity locks on some account balances. + * NOTE: Should only be accessed when setting, changing and freeing a lock. + **/ + locks: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Named reserves on some account balances. + **/ + reserves: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Storage version of the pallet. + * + * This is set to v2.0.0 for new networks. + **/ + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The total units issued in the system. + **/ + totalIssuance: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + bounties: { + /** + * Bounties that have been made. + **/ + bounties: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Bounty indices that have been approved but not yet funded. + **/ + bountyApprovals: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Number of bounty proposals that have been made. + **/ + bountyCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The description of each bounty. + **/ + bountyDescriptions: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + claims: { + claims: AugmentedQuery Observable>, [EthereumAddress]> & QueryableStorageEntry; + /** + * Pre-claimed Ethereum accounts, by the Account ID that they are claimed to. + **/ + preclaims: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The statement kind that must be signed, if any. + **/ + signing: AugmentedQuery Observable>, [EthereumAddress]> & QueryableStorageEntry; + total: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Vesting schedule for a claim. + * First balance is the total amount that should be held for vesting. + * Second balance is how much should be unlocked per block. + * The block number is when the vesting should start. + **/ + vesting: AugmentedQuery Observable>>, [EthereumAddress]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + configuration: { + /** + * The active configuration for the current session. + **/ + activeConfig: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Pending configuration (if any) for the next session. + **/ + pendingConfig: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + council: { + /** + * The current members of the collective. This is stored sorted (just by value). + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The prime member that helps determine the default vote behavior in case of absentations. + **/ + prime: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Proposals so far. + **/ + proposalCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Actual proposal for a given hash, if it's current. + **/ + proposalOf: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The hashes of the active proposals. + **/ + proposals: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Votes on a given proposal, if it is ongoing. + **/ + voting: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + crowdloan: { + /** + * The number of auctions that have entered into their ending period so far. + **/ + endingsCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Info on all of the funds. + **/ + funds: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The funds that have had additional contributions during the last block. This is used + * in order to determine which funds should submit new or updated bids. + **/ + newRaise: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Tracker for the next available trie index + **/ + nextTrieIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + democracy: { + /** + * 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: AugmentedQuery Observable]>>>, [H256]> & QueryableStorageEntry; + /** + * Record of all proposals that have been subject to emergency cancellation. + **/ + cancellations: AugmentedQuery Observable, [H256]> & QueryableStorageEntry; + /** + * Those who have locked a deposit. + * + * TWOX-NOTE: Safe, as increasing integer keys are safe. + **/ + depositOf: AugmentedQuery Observable, u128]>>>, [u32]> & QueryableStorageEntry; + /** + * True if the last referendum tabled was submitted externally. False if it was a public + * proposal. + **/ + lastTabledWasExternal: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Accounts for which there are locks in action which may be removed at some point in the + * future. The value is the block number at which the lock expires and may be removed. + * + * TWOX-NOTE: OK ― `AccountId` is a secure hash. + **/ + locks: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The lowest referendum index representing an unbaked referendum. Equal to + * `ReferendumCount` if there isn't a unbaked referendum. + **/ + lowestUnbaked: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Map of hashes to the proposal preimage, along with who registered it and their deposit. + * The block number is the block at which it was deposited. + **/ + preimages: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The number of (public) proposals that have been made so far. + **/ + publicPropCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The public proposals. Unsorted. The second item is the proposal's hash. + **/ + publicProps: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The next free referendum index, aka the number of referenda started so far. + **/ + referendumCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Information concerning any given referendum. + * + * TWOX-NOTE: SAFE as indexes are not under an attacker’s control. + **/ + referendumInfoOf: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Storage version of the pallet. + * + * New networks start with last version. + **/ + storageVersion: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + dmp: { + /** + * A mapping that stores the downward message queue MQC head for each para. + * + * Each link in this chain has a form: + * `(prev_head, B, H(M))`, where + * - `prev_head`: is the previous head hash or zero if none. + * - `B`: is the relay-chain block number in which a message was appended. + * - `H(M)`: is the hash of the message being appended. + **/ + downwardMessageQueueHeads: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * The downward messages addressed for a certain para. + **/ + downwardMessageQueues: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + electionProviderMultiPhase: { + /** + * Current phase. + **/ + currentPhase: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Desired number of targets to elect for this round. + * + * Only exists when [`Snapshot`] is present. + **/ + desiredTargets: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The minimum score that each 'untrusted' solution must attain in order to be considered + * feasible. + * + * Can be set via `set_minimum_untrusted_score`. + **/ + minimumUntrustedScore: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Current best solution, signed or unsigned, queued to be returned upon `elect`. + **/ + queuedSolution: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Internal counter for the number of rounds. + * + * This is useful for de-duplication of transactions submitted to the pool, and general + * diagnostics of the pallet. + * + * This is merely incremented once per every time that an upstream `elect` is called. + **/ + round: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * A sorted, bounded set of `(score, index)`, where each `index` points to a value in + * `SignedSubmissions`. + * + * We never need to process more than a single signed submission at a time. Signed submissions + * can be quite large, so we're willing to pay the cost of multiple database accesses to access + * them one at a time instead of reading and decoding all of them at once. + **/ + signedSubmissionIndices: AugmentedQuery Observable, u32>>, []> & QueryableStorageEntry; + /** + * The next index to be assigned to an incoming signed submission. + * + * Every accepted submission is assigned a unique index; that index is bound to that particular + * submission for the duration of the election. On election finalization, the next index is + * reset to 0. + * + * We can't just use `SignedSubmissionIndices.len()`, because that's a bounded set; past its + * capacity, it will simply saturate. We can't just iterate over `SignedSubmissionsMap`, + * because iteration is slow. Instead, we store the value here. + **/ + signedSubmissionNextIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Unchecked, signed solutions. + * + * Together with `SubmissionIndices`, this stores a bounded set of `SignedSubmissions` while + * allowing us to keep only a single one in memory at a time. + * + * Twox note: the key of the map is an auto-incrementing index which users cannot inspect or + * affect; we shouldn't need a cryptographically secure hasher. + **/ + signedSubmissionsMap: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Snapshot data of the round. + * + * This is created at the beginning of the signed phase and cleared upon calling `elect`. + **/ + snapshot: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The metadata of the [`RoundSnapshot`] + * + * Only exists when [`Snapshot`] is present. + **/ + snapshotMetadata: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + gilt: { + /** + * The currently active gilts, indexed according to the order of creation. + **/ + active: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Information relating to the gilts currently active. + **/ + activeTotal: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The queues of bids ready to become gilts. Indexed by duration (in `Period`s). + **/ + queues: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The totals of items and balances within each queue. Saves a lot of storage reads in the + * case of sparsely packed queues. + * + * The vector is indexed by duration in `Period`s, offset by one, so information on the queue + * whose duration is one `Period` would be storage `0`. + **/ + queueTotals: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + grandpa: { + /** + * The number of changes (both in terms of keys and underlying economic responsibilities) + * in the "set" of Grandpa validators from genesis. + **/ + currentSetId: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * next block number where we can force a change. + **/ + nextForced: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Pending change: (signaled at, scheduled change). + **/ + pendingChange: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * A mapping from grandpa set ID to the index of the *most recent* session for which its + * members were responsible. + * + * TWOX-NOTE: `SetId` is not under user control. + **/ + setIdSession: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + /** + * `true` if we are currently stalled. + **/ + stalled: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * State of the current authority set. + **/ + state: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + hrmp: { + /** + * This mapping tracks how many open channel requests were accepted by a given recipient para. + * Invariant: `HrmpOpenChannelRequests` should contain the same number of items `(_, X)` with + * `confirmed` set to true, as the number of `HrmpAcceptedChannelRequestCount` for `X`. + **/ + hrmpAcceptedChannelRequestCount: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Storage for the messages for each channel. + * Invariant: cannot be non-empty if the corresponding channel in `HrmpChannels` is `None`. + **/ + hrmpChannelContents: AugmentedQuery Observable>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry; + /** + * Maintains a mapping that can be used to answer the question: + * What paras sent a message at the given block number for a given receiver. + * Invariants: + * - The inner `Vec` is never empty. + * - The inner `Vec` cannot store two same `ParaId`. + * - The outer vector is sorted ascending by block number and cannot store two items with the same + * block number. + **/ + hrmpChannelDigests: AugmentedQuery Observable]>>>, [u32]> & QueryableStorageEntry; + /** + * HRMP channel data associated with each para. + * Invariant: + * - each participant in the channel should satisfy `Paras::is_valid_para(P)` within a session. + **/ + hrmpChannels: AugmentedQuery Observable>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry; + /** + * A set of pending HRMP close channel requests that are going to be closed during the session change. + * Used for checking if a given channel is registered for closure. + * + * The set is accompanied by a list for iteration. + * + * Invariant: + * - There are no channels that exists in list but not in the set and vice versa. + **/ + hrmpCloseChannelRequests: AugmentedQuery Observable>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry; + hrmpCloseChannelRequestsList: AugmentedQuery Observable>, []> & QueryableStorageEntry; + hrmpEgressChannelsIndex: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Ingress/egress indexes allow to find all the senders and receivers given the opposite + * side. I.e. + * + * (a) ingress index allows to find all the senders for a given recipient. + * (b) egress index allows to find all the recipients for a given sender. + * + * Invariants: + * - for each ingress index entry for `P` each item `I` in the index should present in `HrmpChannels` + * as `(I, P)`. + * - for each egress index entry for `P` each item `E` in the index should present in `HrmpChannels` + * as `(P, E)`. + * - there should be no other dangling channels in `HrmpChannels`. + * - the vectors are sorted. + **/ + hrmpIngressChannelsIndex: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * This mapping tracks how many open channel requests are initiated by a given sender para. + * Invariant: `HrmpOpenChannelRequests` should contain the same number of items that has `(X, _)` + * as the number of `HrmpOpenChannelRequestCount` for `X`. + **/ + hrmpOpenChannelRequestCount: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * The set of pending HRMP open channel requests. + * + * The set is accompanied by a list for iteration. + * + * Invariant: + * - There are no channels that exists in list but not in the set and vice versa. + **/ + hrmpOpenChannelRequests: AugmentedQuery Observable>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry; + hrmpOpenChannelRequestsList: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The HRMP watermark associated with each para. + * Invariant: + * - each para `P` used here as a key should satisfy `Paras::is_valid_para(P)` within a session. + **/ + hrmpWatermarks: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + identity: { + /** + * Information that is pertinent to identify the entity behind an account. + * + * TWOX-NOTE: OK ― `AccountId` is a secure hash. + **/ + identityOf: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable]>>, [AccountId32]> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable>>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + imOnline: { + /** + * For each session index, we keep a mapping of `ValidatorId` to the + * number of blocks authored by the given authority. + **/ + authoredBlocks: AugmentedQuery Observable, [u32, AccountId32]> & QueryableStorageEntry; + /** + * The block number after which it's ok to send heartbeats in the current + * session. + * + * At the beginning of each session we set this to a value that should fall + * roughly in the middle of the session duration. The idea is to first wait for + * the validators to produce a block in the current session, so that the + * heartbeat later on will not be necessary. + * + * This value will only be used as a fallback if we fail to get a proper session + * progress estimate from `NextSessionRotation`, as those estimates should be + * more accurate then the value we calculate for `HeartbeatAfter`. + **/ + heartbeatAfter: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The current set of keys that may issue a heartbeat. + **/ + keys: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * For each session index, we keep a mapping of `SessionIndex` and `AuthIndex` to + * `WrapperOpaque`. + **/ + receivedHeartbeats: AugmentedQuery Observable>>, [u32, u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + indices: { + /** + * The lookup from index to account. + **/ + accounts: AugmentedQuery Observable>>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + initializer: { + /** + * Buffered session changes along with the block number at which they should be applied. + * + * Typically this will be empty or one element long. Apart from that this item never hits + * the storage. + * + * However this is a `Vec` regardless to handle various edge cases that may occur at runtime + * upgrade boundaries or if governance intervenes. + **/ + bufferedSessionChanges: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Whether the parachains modules have been initialized within this block. + * + * Semantically a `bool`, but this guarantees it should never hit the trie, + * as this is cleared in `on_finalize` and Frame optimizes `None` values to be empty values. + * + * As a `bool`, `set(false)` and `remove()` both lead to the next `get()` being false, but one of + * them writes to the trie and one does not. This confusion makes `Option<()>` more suitable for + * the semantics of this variable. + **/ + hasInitialized: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + multisig: { + calls: AugmentedQuery Observable>>, [U8aFixed]> & QueryableStorageEntry; + /** + * The set of open multisig operations. + **/ + multisigs: AugmentedQuery Observable>, [AccountId32, U8aFixed]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + offences: { + /** + * A vector of reports of the same kind that happened at the same time slot. + **/ + concurrentReportsIndex: AugmentedQuery Observable>, [U8aFixed, Bytes]> & QueryableStorageEntry; + /** + * The primary structure that holds all offence records keyed by report identifiers. + **/ + reports: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Enumerates all reports of a kind along with the time they happened. + * + * All reports are sorted by the time of offence. + * + * Note that the actual type of this mapping is `Vec`, this is because values of + * different types are not supported at the moment so we are doing the manual serialization. + **/ + reportsByKindIndex: AugmentedQuery Observable, [U8aFixed]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paraInclusion: { + /** + * The latest bitfield for each validator, referred to by their index in the validator set. + **/ + availabilityBitfields: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Candidates pending availability by `ParaId`. + **/ + pendingAvailability: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The commitments of candidates pending availability, by `ParaId`. + **/ + pendingAvailabilityCommitments: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paraInherent: { + /** + * Whether the paras inherent was included within this block. + * + * The `Option<()>` is effectively a `bool`, but it never hits storage in the `None` variant + * due to the guarantees of FRAME's storage APIs. + * + * If this is `None` at the end of the block, we panic and render the block invalid. + **/ + included: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Scraped on chain data for extracting resolved disputes as well as backing votes. + **/ + onChainVotes: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paras: { + /** + * The actions to perform during the start of a specific session index. + **/ + actionsQueue: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Validation code stored by its hash. + * + * This storage is consistent with [`FutureCodeHash`], [`CurrentCodeHash`] and + * [`PastCodeHash`]. + **/ + codeByHash: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The number of reference on the validation code in [`CodeByHash`] storage. + **/ + codeByHashRefs: AugmentedQuery Observable, [H256]> & QueryableStorageEntry; + /** + * The validation code hash of every live para. + * + * Corresponding code can be retrieved with [`CodeByHash`]. + **/ + currentCodeHash: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The actual future code hash of a para. + * + * Corresponding code can be retrieved with [`CodeByHash`]. + **/ + futureCodeHash: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The block number at which the planned code change is expected for a para. + * The change will be applied after the first parablock for this ID included which executes + * in the context of a relay chain block with a number >= `expected_at`. + **/ + futureCodeUpgrades: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The head-data of every registered para. + **/ + heads: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * All parachains. Ordered ascending by `ParaId`. Parathreads are not included. + **/ + parachains: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current lifecycle of a all known Para IDs. + **/ + paraLifecycles: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Actual past code hash, indicated by the para id as well as the block number at which it + * became outdated. + * + * Corresponding code can be retrieved with [`CodeByHash`]. + **/ + pastCodeHash: AugmentedQuery | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable>, [ITuple<[u32, u32]>]> & QueryableStorageEntry]>; + /** + * Past code of parachains. The parachains themselves may not be registered anymore, + * but we also keep their code on-chain for the same amount of time as outdated code + * to keep it available for secondary checkers. + **/ + pastCodeMeta: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Which paras have past code that needs pruning and the relay-chain block at which the code was replaced. + * Note that this is the actual height of the included block, not the expected height at which the + * code upgrade would be applied, although they may be equal. + * This is to ensure the entire acceptance period is covered, not an offset acceptance period starting + * from the time at which the parachain perceives a code upgrade as having occurred. + * Multiple entries for a single para are permitted. Ordered ascending by block number. + **/ + pastCodePruning: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The list of all currently active PVF votes. Auxiliary to `PvfActiveVoteMap`. + **/ + pvfActiveVoteList: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * All currently active PVF pre-checking votes. + * + * Invariant: + * - There are no PVF pre-checking votes that exists in list but not in the set and vice versa. + **/ + pvfActiveVoteMap: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Upcoming paras instantiation arguments. + * + * NOTE that after PVF pre-checking is enabled the para genesis arg will have it's code set + * to empty. Instead, the code will be saved into the storage right away via `CodeByHash`. + **/ + upcomingParasGenesis: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The list of upcoming code upgrades. Each item is a pair of which para performs a code + * upgrade and at which relay-chain block it is expected at. + * + * Ordered ascending by block number. + **/ + upcomingUpgrades: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The list of parachains that are awaiting for their upgrade restriction to cooldown. + * + * Ordered ascending by block number. + **/ + upgradeCooldowns: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * This is used by the relay-chain to communicate to a parachain a go-ahead with in the upgrade procedure. + * + * This value is absent when there are no upgrades scheduled or during the time the relay chain + * performs the checks. It is set at the first relay-chain block when the corresponding parachain + * can switch its upgrade function. As soon as the parachain's block is included, the value + * gets reset to `None`. + * + * NOTE that this field is used by parachains via merkle storage proofs, therefore changing + * the format will require migration of parachains. + **/ + upgradeGoAheadSignal: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * This is used by the relay-chain to communicate that there are restrictions for performing + * an upgrade for this parachain. + * + * This may be a because the parachain waits for the upgrade cooldown to expire. Another + * potential use case is when we want to perform some maintenance (such as storage migration) + * we could restrict upgrades to make the process simpler. + * + * NOTE that this field is used by parachains via merkle storage proofs, therefore changing + * the format will require migration of parachains. + **/ + upgradeRestrictionSignal: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paraScheduler: { + /** + * One entry for each availability core. Entries are `None` if the core is not currently occupied. Can be + * temporarily `Some` if scheduled but not occupied. + * The i'th parachain belongs to the i'th core, with the remaining cores all being + * parathread-multiplexers. + * + * Bounded by the maximum of either of these two values: + * * The number of parachains and parathread multiplexers + * * The number of validators divided by `configuration.max_validators_per_core`. + **/ + availabilityCores: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * An index used to ensure that only one claim on a parathread exists in the queue or is + * currently being handled by an occupied core. + * + * Bounded by the number of parathread cores and scheduling lookahead. Reasonably, 10 * 50 = 500. + **/ + parathreadClaimIndex: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * A queue of upcoming claims and which core they should be mapped onto. + * + * The number of queued claims is bounded at the `scheduling_lookahead` + * multiplied by the number of parathread multiplexer cores. Reasonably, 10 * 50 = 500. + **/ + parathreadQueue: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Currently scheduled cores - free but up to be occupied. + * + * Bounded by the number of cores: one for each parachain and parathread multiplexer. + * + * The value contained here will not be valid after the end of a block. Runtime APIs should be used to determine scheduled cores/ + * for the upcoming block. + **/ + scheduled: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The block number where the session start occurred. Used to track how many group rotations have occurred. + * + * Note that in the context of parachains modules the session change is signaled during + * the block and enacted at the end of the block (at the finalization stage, to be exact). + * Thus for all intents and purposes the effect of the session change is observed at the + * block following the session change, block number of which we save in this storage value. + **/ + sessionStartBlock: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * All the validator groups. One for each core. Indices are into `ActiveValidators` - not the + * broader set of Polkadot validators, but instead just the subset used for parachains during + * this session. + * + * Bound: The number of cores is the sum of the numbers of parachains and parathread multiplexers. + * Reasonably, 100-1000. The dominant factor is the number of validators: safe upper bound at 10k. + **/ + validatorGroups: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + parasDisputes: { + /** + * All ongoing or concluded disputes for the last several sessions. + **/ + disputes: AugmentedQuery Observable>, [u32, H256]> & QueryableStorageEntry; + /** + * Whether the chain is frozen. Starts as `None`. When this is `Some`, + * the chain will not accept any new parachain blocks for backing or inclusion, + * and its value indicates the last valid block number in the chain. + * It can only be set back to `None` by governance intervention. + **/ + frozen: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * All included blocks on the chain, as well as the block number in this chain that + * should be reverted back to if the candidate is disputed and determined to be invalid. + **/ + included: AugmentedQuery Observable>, [u32, H256]> & QueryableStorageEntry; + /** + * The last pruned session, if any. All data stored by this module + * references sessions. + **/ + lastPrunedSession: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Maps session indices to a vector indicating the number of potentially-spam disputes + * each validator is participating in. Potentially-spam disputes are remote disputes which have + * fewer than `byzantine_threshold + 1` validators. + * + * The i'th entry of the vector corresponds to the i'th validator in the session. + **/ + spamSlots: AugmentedQuery Observable>>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paraSessionInfo: { + /** + * Assignment keys for the current session. + * Note that this API is private due to it being prone to 'off-by-one' at session boundaries. + * When in doubt, use `Sessions` API instead. + **/ + assignmentKeysUnsafe: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The earliest session for which previous session info is stored. + **/ + earliestStoredSession: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Session information in a rolling window. + * Should have an entry in range `EarliestStoredSession..=CurrentSessionIndex`. + * Does not have any entries before the session index in the first session change notification. + **/ + sessions: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + parasShared: { + /** + * All the validators actively participating in parachain consensus. + * Indices are into the broader validator set. + **/ + activeValidatorIndices: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The parachain attestation keys of the validators actively participating in parachain consensus. + * This should be the same length as `ActiveValidatorIndices`. + **/ + activeValidatorKeys: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current session index. + **/ + currentSessionIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + phragmenElection: { + /** + * The present candidate list. A current member or runner-up can never enter this vector + * and is always implicitly assumed to be a candidate. + * + * Second element is the deposit. + * + * Invariant: Always sorted based on account id. + **/ + candidates: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The total number of vote rounds that have happened, excluding the upcoming one. + **/ + electionRounds: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The current elected members. + * + * Invariant: Always sorted based on account id. + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current reserved runners-up. + * + * Invariant: Always sorted based on rank (worse to best). Upon removal of a member, the + * last (i.e. _best_) runner-up will be replaced. + **/ + runnersUp: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Votes and locked stake of a particular voter. + * + * TWOX-NOTE: SAFE as `AccountId` is a crypto hash. + **/ + voting: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + preimage: { + /** + * The preimages stored by this pallet. + **/ + preimageFor: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The request status of a given hash. + **/ + statusFor: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + proxy: { + /** + * The announcements made by the proxy (key). + **/ + announcements: AugmentedQuery Observable, u128]>>, [AccountId32]> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable, u128]>>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + recovery: { + /** + * Active recovery attempts. + * + * First account is the account to be recovered, and the second account + * is the user trying to recover the account. + **/ + activeRecoveries: AugmentedQuery Observable>, [AccountId32, AccountId32]> & QueryableStorageEntry; + /** + * The list of allowed proxy accounts. + * + * Map from the user who can access it to the recovered account. + **/ + proxy: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The set of recoverable accounts and their recovery configuration. + **/ + recoverable: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + registrar: { + /** + * The next free `ParaId`. + **/ + nextFreeParaId: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Amount held on deposit for each para and the original depositor. + * + * The given account ID is responsible for registering the code and initial head data, but may only do + * so if it isn't yet registered. (After that, it's up to governance to do so.) + **/ + paras: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Pending swap operations. + **/ + pendingSwap: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + scheduler: { + /** + * Items to be executed, indexed by the block number that they should be executed on. + **/ + agenda: AugmentedQuery Observable>>, [u32]> & QueryableStorageEntry; + /** + * Lookup from identity to the block number and index of the task. + **/ + lookup: AugmentedQuery Observable>>, [Bytes]> & QueryableStorageEntry; + /** + * Storage version of the pallet. + * + * New networks start with last version. + **/ + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + session: { + /** + * Current index of the session. + **/ + currentIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Indices of disabled validators. + * + * The vec is always kept sorted so that we can find whether a given validator is + * disabled using binary search. It gets cleared when `on_session_ending` returns + * a new set of identities. + **/ + disabledValidators: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The owner of a key. The key is the `KeyTypeId` + the encoded key. + **/ + keyOwner: AugmentedQuery | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry]>; + /** + * The next session keys for a validator. + **/ + nextKeys: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * True if the underlying economic identities or weighting behind the validators + * has changed in the queued validator set. + **/ + queuedChanged: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The queued keys for the next session. When the next session begins, these keys + * will be used to determine the validator's session keys. + **/ + queuedKeys: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The current set of validators. + **/ + validators: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + slots: { + /** + * Amounts held on deposit for each (possibly future) leased parachain. + * + * The actual amount locked on its behalf by any account at any time is the maximum of the second values + * of the items in this list whose first value is the account. + * + * The first item in the list is the amount locked for the current Lease Period. Following + * items are for the subsequent lease periods. + * + * The default value (an empty list) implies that the parachain no longer exists (or never + * existed) as far as this pallet is concerned. + * + * If a parachain doesn't exist *yet* but is scheduled to exist in the future, then it + * will be left-padded with one or more `None`s to denote the fact that nothing is held on + * deposit for the non-existent chain currently, but is held at some point in the future. + * + * It is illegal for a `None` value to trail in the list. + **/ + leases: AugmentedQuery Observable>>>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + society: { + /** + * The current bids, stored ordered by the value of the bid. + **/ + bids: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current set of candidates; bidders that are attempting to become members. + **/ + candidates: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The defending member currently being challenged. + **/ + defender: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Votes for the defender. + **/ + defenderVotes: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The first member. + **/ + founder: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The most primary from the most recently approved members. + **/ + head: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The max number of members for the society at one time. + **/ + maxMembers: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The current set of members, ordered. + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Pending payouts; ordered by block number, with the amount that should be paid out. + **/ + payouts: AugmentedQuery Observable>>, [AccountId32]> & QueryableStorageEntry; + /** + * Amount of our account balance that is specifically for the next round's bid(s). + **/ + pot: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * A hash of the rules of this society concerning membership. Can only be set once and + * only by the founder. + **/ + rules: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The ongoing number of losing votes cast by the member. + **/ + strikes: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * The set of suspended candidates. + **/ + suspendedCandidates: AugmentedQuery Observable>>, [AccountId32]> & QueryableStorageEntry; + /** + * The set of suspended members. + **/ + suspendedMembers: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Double map from Candidate -> Voter -> (Maybe) Vote. + **/ + votes: AugmentedQuery Observable>, [AccountId32, AccountId32]> & QueryableStorageEntry; + /** + * Members currently vouching or banned from vouching again + **/ + vouching: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + staking: { + /** + * The active era information, it holds index and start. + * + * The active era is the era being currently rewarded. Validator set of this era must be + * equal to [`SessionInterface::validators`]. + **/ + activeEra: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Map from all locked "stash" accounts to the controller account. + **/ + bonded: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * A mapping from still-bonded eras to the first session index of that era. + * + * Must contains information for eras for the range: + * `[active_era - bounding_duration; active_era]` + **/ + bondedEras: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The amount of currency given to reporters of a slash event which was + * canceled by extraordinary circumstances (e.g. governance). + **/ + canceledSlashPayout: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The threshold for when users can start calling `chill_other` for other validators / + * nominators. The threshold is compared to the actual number of validators / nominators + * (`CountFor*`) in the system compared to the configured max (`Max*Count`). + **/ + chillThreshold: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Counter for the related counted storage map + **/ + counterForNominators: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Counter for the related counted storage map + **/ + counterForValidators: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The current era index. + * + * This is the latest planned era, depending on how the Session pallet queues the validator + * set, it might be active or not. + **/ + currentEra: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The last planned session scheduled by the session pallet. + * + * This is basically in sync with the call to [`pallet_session::SessionManager::new_session`]. + **/ + currentPlannedSession: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The earliest era for which we have a pending, unapplied slash. + **/ + earliestUnappliedSlash: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Rewards for the last `HISTORY_DEPTH` eras. + * If reward hasn't been set or has been removed then 0 reward is returned. + **/ + erasRewardPoints: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Exposure of validator at era. + * + * This is keyed first by the era index to allow bulk deletion and then the stash account. + * + * Is it removed after `HISTORY_DEPTH` eras. + * If stakers hasn't been set or has been removed then empty exposure is returned. + **/ + erasStakers: AugmentedQuery Observable, [u32, AccountId32]> & QueryableStorageEntry; + /** + * Clipped Exposure of validator at era. + * + * This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the + * `T::MaxNominatorRewardedPerValidator` biggest stakers. + * (Note: the field `total` and `own` of the exposure remains unchanged). + * This is used to limit the i/o cost for the nominator payout. + * + * This is keyed fist by the era index to allow bulk deletion and then the stash account. + * + * Is it removed after `HISTORY_DEPTH` eras. + * If stakers hasn't been set or has been removed then empty exposure is returned. + **/ + erasStakersClipped: AugmentedQuery Observable, [u32, AccountId32]> & QueryableStorageEntry; + /** + * The session index at which the era start for the last `HISTORY_DEPTH` eras. + * + * Note: This tracks the starting session (i.e. session index when era start being active) + * for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`. + **/ + erasStartSessionIndex: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The total amount staked for the last `HISTORY_DEPTH` eras. + * If total hasn't been set or has been removed then 0 stake is returned. + **/ + erasTotalStake: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Similar to `ErasStakers`, this holds the preferences of validators. + * + * This is keyed first by the era index to allow bulk deletion and then the stash account. + * + * Is it removed after `HISTORY_DEPTH` eras. + **/ + erasValidatorPrefs: AugmentedQuery Observable, [u32, AccountId32]> & QueryableStorageEntry; + /** + * The total validator era payout for the last `HISTORY_DEPTH` eras. + * + * Eras that haven't finished yet or has been removed doesn't have reward. + **/ + erasValidatorReward: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Mode of era forcing. + **/ + forceEra: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Number of eras to keep in history. + * + * Information is kept for eras in `[current_era - history_depth; current_era]`. + * + * Must be more than the number of eras delayed by session otherwise. I.e. active era must + * always be in history. I.e. `active_era > current_era - history_depth` must be + * guaranteed. + **/ + historyDepth: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Any validators that may never be slashed or forcibly kicked. It's a Vec since they're + * easy to initialize and the performance hit is minimal (we expect no more than four + * invulnerables) and restricted to testnets. + **/ + invulnerables: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Map from all (unlocked) "controller" accounts to the info regarding the staking. + **/ + ledger: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The maximum nominator count before we stop allowing new validators to join. + * + * When this value is not set, no limits are enforced. + **/ + maxNominatorsCount: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The maximum validator count before we stop allowing new validators to join. + * + * When this value is not set, no limits are enforced. + **/ + maxValidatorsCount: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The minimum amount of commission that validators can set. + * + * If set to `0`, no limit exists. + **/ + minCommission: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Minimum number of staking participants before emergency conditions are imposed. + **/ + minimumValidatorCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The minimum active bond to become and maintain the role of a nominator. + **/ + minNominatorBond: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The minimum active bond to become and maintain the role of a validator. + **/ + minValidatorBond: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The map from nominator stash key to the set of stash keys of all validators to nominate. + **/ + nominators: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * All slashing events on nominators, mapped by era to the highest slash value of the era. + **/ + nominatorSlashInEra: AugmentedQuery Observable>, [u32, AccountId32]> & QueryableStorageEntry; + /** + * Indices of validators that have offended in the active era and whether they are currently + * disabled. + * + * This value should be a superset of disabled validators since not all offences lead to the + * validator being disabled (if there was no slash). This is needed to track the percentage of + * validators that have offended in the current era, ensuring a new era is forced if + * `OffendingValidatorsThreshold` is reached. The vec is always kept sorted so that we can find + * whether a given validator has previously offended using binary search. It gets cleared when + * the era ends. + **/ + offendingValidators: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Where the reward payment should be made. Keyed by stash. + **/ + payee: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Slashing spans for stash accounts. + **/ + slashingSpans: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The percentage of the slash that is distributed to reporters. + * + * The rest of the slashed value is handled by the `Slash`. + **/ + slashRewardFraction: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Records information about the maximum slash of a stash within a slashing span, + * as well as how much reward has been paid out. + **/ + spanSlash: AugmentedQuery | [AccountId32 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable, [ITuple<[AccountId32, u32]>]> & QueryableStorageEntry]>; + /** + * True if network has been upgraded to this version. + * Storage version of the pallet. + * + * This is set to v7.0.0 for new networks. + **/ + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * All unapplied slashes that are queued for later. + **/ + unappliedSlashes: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The ideal number of staking participants. + **/ + validatorCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The map from (wannabe) validator stash key to the preferences of that validator. + **/ + validators: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * All slashing events on validators, mapped by era to the highest slash proportion + * and slash value of the era. + **/ + validatorSlashInEra: AugmentedQuery Observable>>, [u32, AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + system: { + /** + * The full account information for a particular account ID. + **/ + account: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Total length (in bytes) for all extrinsics put together, for the current block. + **/ + allExtrinsicsLen: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Map of block numbers to block hashes. + **/ + blockHash: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * The current weight for the block. + **/ + blockWeight: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Digest of the current block, also part of the block header. + **/ + digest: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The number of events in the `Events` list. + **/ + eventCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Events deposited for the current block. + * + * NOTE: This storage item is explicitly unbounded since it is never intended to be read + * from within the runtime. + **/ + events: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * 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 `(T::BlockNumber, 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: AugmentedQuery Observable>>, [H256]> & QueryableStorageEntry; + /** + * The execution phase of the block. + **/ + executionPhase: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Total extrinsics count for the current block. + **/ + extrinsicCount: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Extrinsics data for the current block (maps an extrinsic's index to its data). + **/ + extrinsicData: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened. + **/ + lastRuntimeUpgrade: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current block number being processed. Set by `execute_block`. + **/ + number: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Hash of the previous block. + **/ + parentHash: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False + * (default) if not. + **/ + upgradedToTripleRefCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not. + **/ + upgradedToU32RefCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + technicalCommittee: { + /** + * The current members of the collective. This is stored sorted (just by value). + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The prime member that helps determine the default vote behavior in case of absentations. + **/ + prime: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Proposals so far. + **/ + proposalCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Actual proposal for a given hash, if it's current. + **/ + proposalOf: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The hashes of the active proposals. + **/ + proposals: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Votes on a given proposal, if it is ongoing. + **/ + voting: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + technicalMembership: { + /** + * The current membership, stored as an ordered Vec. + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current prime member, if one exists. + **/ + prime: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + timestamp: { + /** + * Did the timestamp get updated in this block? + **/ + didUpdate: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Current time for the current block. + **/ + now: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + tips: { + /** + * Simple preimage lookup from the reason's hash to the original data. Again, has an + * insecure enumerable hash since the key is guaranteed to be the result of a secure hash. + **/ + reasons: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * TipsMap that are not yet completed. Keyed by the hash of `(reason, who)` from the value. + * This has the insecure enumerable hash function since the key itself is already + * guaranteed to be a secure hash. + **/ + tips: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + transactionPayment: { + nextFeeMultiplier: AugmentedQuery Observable, []> & QueryableStorageEntry; + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + treasury: { + /** + * Proposal indices that have been approved but not yet awarded. + **/ + approvals: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Number of proposals that have been made. + **/ + proposalCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Proposals that have been made. + **/ + proposals: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + ump: { + /** + * The ordered list of `ParaId`s that have a `RelayDispatchQueue` entry. + * + * Invariant: + * - The set of items from this vector should be exactly the set of the keys in + * `RelayDispatchQueues` and `RelayDispatchQueueSize`. + **/ + needsDispatch: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * This is the para that gets will get dispatched first during the next upward dispatchable queue + * execution round. + * + * Invariant: + * - If `Some(para)`, then `para` must be present in `NeedsDispatch`. + **/ + nextDispatchRoundStartWith: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The messages that exceeded max individual message weight budget. + * + * These messages stay there until manually dispatched. + **/ + overweight: AugmentedQuery Observable>>, [u64]> & QueryableStorageEntry; + /** + * The number of overweight messages ever recorded in `Overweight` (and thus the lowest free + * index). + **/ + overweightCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The messages waiting to be handled by the relay-chain originating from a certain parachain. + * + * Note that some upward messages might have been already processed by the inclusion logic. E.g. + * channel management messages. + * + * The messages are processed in FIFO order. + **/ + relayDispatchQueues: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Size of the dispatch queues. Caches sizes of the queues in `RelayDispatchQueue`. + * + * First item in the tuple is the count of messages and second + * is the total length (in bytes) of the message payloads. + * + * Note that this is an auxiliary mapping: it's possible to tell the byte size and the number of + * messages only looking at `RelayDispatchQueues`. This mapping is separate to avoid the cost of + * loading the whole message queue if only the total size and count are required. + * + * Invariant: + * - The set of keys should exactly match the set of keys of `RelayDispatchQueues`. + **/ + relayDispatchQueueSize: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + vesting: { + /** + * Storage version of the pallet. + * + * New networks start with latest version, as determined by the genesis build. + **/ + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Information regarding the vesting of a given account. + **/ + vesting: AugmentedQuery Observable>>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + xcmPallet: { + /** + * The existing asset traps. + * + * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of + * times this pair has been trapped (usually just 1 if it exists at all). + **/ + assetTraps: AugmentedQuery Observable, [H256]> & QueryableStorageEntry; + /** + * The current migration's stage, if any. + **/ + currentMigration: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The ongoing queries. + **/ + queries: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + /** + * The latest available query index. + **/ + queryCounter: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Default version to encode XCM when latest version of destination is unknown. If `None`, + * then the destinations whose XCM version is unknown are considered unreachable. + **/ + safeXcmVersion: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The Latest versions that we know various locations support. + **/ + supportedVersion: AugmentedQuery Observable>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry; + /** + * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and + * the `u32` counter is the number of times that a send to the destination has been attempted, + * which is used as a prioritization. + **/ + versionDiscoveryQueue: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * All locations that we have requested version notifications from. + **/ + versionNotifiers: AugmentedQuery Observable>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry; + /** + * The target locations that are subscribed to our version changes, as well as the most recent + * of our versions we informed them of. + **/ + versionNotifyTargets: AugmentedQuery Observable>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + } // AugmentedQueries +} // declare module diff --git a/packages/api-augment/src/kusama/tx.ts b/packages/api-augment/src/kusama/tx.ts new file mode 100644 index 0000000000..526a0918be --- /dev/null +++ b/packages/api-augment/src/kusama/tx.ts @@ -0,0 +1,4297 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; +import type { Data } from '@polkadot/types'; +import type { Bytes, Compact, Option, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { AnyNumber, ITuple } from '@polkadot/types-codec/types'; +import type { EthereumAddress } from '@polkadot/types/interfaces/eth'; +import type { AccountId32, Call, H256, MultiAddress, Perbill, Percent, Perquintill } from '@polkadot/types/interfaces/runtime'; +import type { FrameSupportScheduleMaybeHashed, KusamaRuntimeOriginCaller, KusamaRuntimeProxyType, KusamaRuntimeSessionKeys, PalletDemocracyConviction, PalletDemocracyVoteAccountVote, PalletElectionProviderMultiPhaseRawSolution, PalletElectionProviderMultiPhaseSolutionOrSnapshotSize, PalletElectionsPhragmenRenouncing, PalletIdentityBitFlags, PalletIdentityIdentityInfo, PalletIdentityJudgement, PalletImOnlineHeartbeat, PalletImOnlineSr25519AppSr25519Signature, PalletMultisigTimepoint, PalletSocietyJudgement, PalletStakingRewardDestination, PalletStakingValidatorPrefs, PalletVestingVestingInfo, PolkadotParachainPrimitivesHrmpChannelId, PolkadotPrimitivesV0ValidatorAppSignature, PolkadotPrimitivesV1InherentData, PolkadotPrimitivesV1PvfCheckStatement, PolkadotRuntimeCommonClaimsEcdsaSignature, PolkadotRuntimeCommonClaimsStatementKind, SpConsensusBabeDigestsNextConfigDescriptor, SpConsensusSlotsEquivocationProof, SpFinalityGrandpaEquivocationProof, SpNposElectionsSupport, SpRuntimeHeader, SpRuntimeMultiSignature, SpRuntimeMultiSigner, SpSessionMembershipProof, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; + +declare module '@polkadot/api-base/types/submittable' { + export interface AugmentedSubmittables { + auctions: { + /** + * Make a new bid from an account (including a parachain account) for deploying a new + * parachain. + * + * Multiple simultaneous bids from the same bidder are allowed only as long as all active + * bids overlap each other (i.e. are mutually exclusive). Bids cannot be redacted. + * + * - `sub` is the sub-bidder ID, allowing for multiple competing bids to be made by (and + * funded by) the same account. + * - `auction_index` is the index of the auction to bid on. Should just be the present + * value of `AuctionCounter`. + * - `first_slot` is the first lease period index of the range to bid on. This is the + * absolute lease period index value, not an auction-specific offset. + * - `last_slot` is the last lease period index of the range to bid on. This is the + * absolute lease period index value, not an auction-specific offset. + * - `amount` is the amount to bid to be held as deposit for the parachain should the + * bid win. This amount is held throughout the range. + **/ + bid: AugmentedSubmittable<(para: Compact | AnyNumber | Uint8Array, auctionIndex: Compact | AnyNumber | Uint8Array, firstSlot: Compact | AnyNumber | Uint8Array, lastSlot: Compact | AnyNumber | Uint8Array, amount: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact, Compact, Compact, Compact]>; + /** + * Cancel an in-progress auction. + * + * Can only be called by Root origin. + **/ + cancelAuction: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Create a new auction. + * + * This can only happen when there isn't already an auction in progress and may only be + * called by the root origin. Accepts the `duration` of this auction and the + * `lease_period_index` of the initial lease period of the four that are to be auctioned. + **/ + newAuction: AugmentedSubmittable<(duration: Compact | AnyNumber | Uint8Array, leasePeriodIndex: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + authorship: { + /** + * Provide a set of uncles. + **/ + setUncles: AugmentedSubmittable<(newUncles: Vec | (SpRuntimeHeader | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + babe: { + /** + * Plan an epoch config change. The epoch config change is recorded and will be enacted on + * the next call to `enact_epoch_change`. The config will be activated one epoch after. + * Multiple calls to this method will replace any existing planned config change that had + * not been enacted yet. + **/ + planConfigChange: AugmentedSubmittable<(config: SpConsensusBabeDigestsNextConfigDescriptor | { V1: any } | string | Uint8Array) => SubmittableExtrinsic, [SpConsensusBabeDigestsNextConfigDescriptor]>; + /** + * Report authority equivocation/misbehavior. This method will verify + * the equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence will + * be reported. + **/ + reportEquivocation: AugmentedSubmittable<(equivocationProof: SpConsensusSlotsEquivocationProof | { offender?: any; slot?: any; firstHeader?: any; secondHeader?: any } | string | Uint8Array, keyOwnerProof: SpSessionMembershipProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic, [SpConsensusSlotsEquivocationProof, SpSessionMembershipProof]>; + /** + * Report authority equivocation/misbehavior. This method will verify + * the equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence will + * be reported. + * This extrinsic must be called unsigned and it is expected that only + * block authors will call it (validated in `ValidateUnsigned`), as such + * if the block author is defined it will be defined as the equivocation + * reporter. + **/ + reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: SpConsensusSlotsEquivocationProof | { offender?: any; slot?: any; firstHeader?: any; secondHeader?: any } | string | Uint8Array, keyOwnerProof: SpSessionMembershipProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic, [SpConsensusSlotsEquivocationProof, SpSessionMembershipProof]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + bagsList: { + /** + * Move the caller's Id directly in front of `lighter`. + * + * The dispatch origin for this call must be _Signed_ and can only be called by the Id of + * the account going in front of `lighter`. + * + * Only works if + * - both nodes are within the same bag, + * - and `origin` has a greater `VoteWeight` than `lighter`. + **/ + putInFrontOf: AugmentedSubmittable<(lighter: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Declare that some `dislocated` account has, through rewards or penalties, sufficiently + * changed its weight that it should properly fall into a different bag than its current + * one. + * + * Anyone can call this function about any potentially dislocated account. + * + * Will never return an error; if `dislocated` does not exist or doesn't need a rebag, then + * it is a noop and fees are still collected from `origin`. + **/ + rebag: AugmentedSubmittable<(dislocated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + balances: { + /** + * Exactly as `transfer`, except the origin must be root and the source account may be + * specified. + * # + * - Same as transfer, but additional read and write because the source account is not + * assumed to be in the overlay. + * # + **/ + forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, MultiAddress, Compact]>; + /** + * Unreserve some balance from a user by force. + * + * Can only be called by ROOT. + **/ + forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, u128]>; + /** + * 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 reset the account nonce (`frame_system::AccountNonce`). + * + * The dispatch origin for this call is `root`. + **/ + setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact | AnyNumber | Uint8Array, newReserved: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact, Compact]>; + /** + * 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. + * + * # + * - Dependent on arguments but not critical, given proper implementations for input config + * types. See related functions below. + * - It contains a limited number of reads and writes internally and no complex + * computation. + * + * Related functions: + * + * - `ensure_can_withdraw` is always called internally but has a bounded complexity. + * - Transferring balances to accounts that did not exist before will cause + * `T::OnNewAccount::on_new_account` to be called. + * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`. + * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check + * that the transfer will not kill the origin account. + * --------------------------------- + * - Origin account is already in memory, so no DB operations for them. + * # + **/ + transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact]>; + /** + * Transfer the entire transferable balance from the caller account. + * + * NOTE: This function only attempts to transfer _transferable_ balances. This means that + * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be + * transferred by this function. To ensure that this function results in a killed account, + * you might need to prepare the account by removing any reference counters, storage + * deposits, etc... + * + * The dispatch origin of this call must be Signed. + * + * - `dest`: The recipient of the transfer. + * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all + * of the funds the account has, causing the sender account to be killed (false), or + * transfer everything except at least the existential deposit, which will guarantee to + * keep the sender account alive (true). # + * - O(1). Just like transfer, but reading the user's transferable balance first. + * # + **/ + transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic, [MultiAddress, bool]>; + /** + * 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. + * + * [`transfer`]: struct.Pallet.html#method.transfer + **/ + transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + bounties: { + /** + * Accept the curator role for a bounty. + * A deposit will be reserved from curator and refund upon successful payout. + * + * May only be called from the curator. + * + * # + * - O(1). + * # + **/ + acceptCurator: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Approve a bounty proposal. At a later time, the bounty will be funded and become active + * and the original deposit will be returned. + * + * May only be called from `T::ApproveOrigin`. + * + * # + * - O(1). + * # + **/ + approveBounty: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Award bounty to a beneficiary account. The beneficiary will be able to claim the funds + * after a delay. + * + * The dispatch origin for this call must be the curator of this bounty. + * + * - `bounty_id`: Bounty ID to award. + * - `beneficiary`: The beneficiary account whom will receive the payout. + * + * # + * - O(1). + * # + **/ + awardBounty: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array, beneficiary: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [Compact, MultiAddress]>; + /** + * Claim the payout from an awarded bounty after payout delay. + * + * The dispatch origin for this call must be the beneficiary of this bounty. + * + * - `bounty_id`: Bounty ID to claim. + * + * # + * - O(1). + * # + **/ + claimBounty: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Cancel a proposed or active bounty. All the funds will be sent to treasury and + * the curator deposit will be unreserved if possible. + * + * Only `T::RejectOrigin` is able to cancel a bounty. + * + * - `bounty_id`: Bounty ID to cancel. + * + * # + * - O(1). + * # + **/ + closeBounty: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Extend the expiry time of an active bounty. + * + * The dispatch origin for this call must be the curator of this bounty. + * + * - `bounty_id`: Bounty ID to extend. + * - `remark`: additional information. + * + * # + * - O(1). + * # + **/ + extendBountyExpiry: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array, remark: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Compact, Bytes]>; + /** + * Propose a new bounty. + * + * The dispatch origin for this call must be _Signed_. + * + * Payment: `TipReportDepositBase` will be reserved from the origin account, as well as + * `DataDepositPerByte` for each byte in `reason`. It will be unreserved upon approval, + * or slashed when rejected. + * + * - `curator`: The curator account whom will manage this bounty. + * - `fee`: The curator fee. + * - `value`: The total payment amount of this bounty, curator fee included. + * - `description`: The description of this bounty. + **/ + proposeBounty: AugmentedSubmittable<(value: Compact | AnyNumber | Uint8Array, description: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Compact, Bytes]>; + /** + * Assign a curator to a funded bounty. + * + * May only be called from `T::ApproveOrigin`. + * + * # + * - O(1). + * # + **/ + proposeCurator: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array, curator: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, fee: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, MultiAddress, Compact]>; + /** + * Unassign curator from a bounty. + * + * This function can only be called by the `RejectOrigin` a signed origin. + * + * If this function is called by the `RejectOrigin`, we assume that the curator is + * malicious or inactive. As a result, we will slash the curator when possible. + * + * If the origin is the curator, we take this as a sign they are unable to do their job and + * they willingly give up. We could slash them, but for now we allow them to recover their + * deposit and exit without issue. (We may want to change this if it is abused.) + * + * Finally, the origin can be anyone if and only if the curator is "inactive". This allows + * anyone in the community to call out that a curator is not doing their due diligence, and + * we should pick a new curator. In this case the curator should also be slashed. + * + * # + * - O(1). + * # + **/ + unassignCurator: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + claims: { + /** + * Attest to a statement, needed to finalize the claims process. + * + * WARNING: Insecure unless your chain includes `PrevalidateAttests` as a `SignedExtension`. + * + * Unsigned Validation: + * A call to attest is deemed valid if the sender has a `Preclaim` registered + * and provides a `statement` which is expected for the account. + * + * Parameters: + * - `statement`: The identity of the statement which is being attested to in the signature. + * + * + * The weight of this call is invariant over the input parameters. + * Weight includes logic to do pre-validation on `attest` call. + * + * Total Complexity: O(1) + * + **/ + attest: AugmentedSubmittable<(statement: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Make a claim to collect your DOTs. + * + * The dispatch origin for this call must be _None_. + * + * Unsigned Validation: + * A call to claim is deemed valid if the signature provided matches + * the expected signed message of: + * + * > Ethereum Signed Message: + * > (configured prefix string)(address) + * + * and `address` matches the `dest` account. + * + * Parameters: + * - `dest`: The destination account to payout the claim. + * - `ethereum_signature`: The signature of an ethereum signed message + * matching the format described above. + * + * + * The weight of this call is invariant over the input parameters. + * Weight includes logic to validate unsigned `claim` call. + * + * Total Complexity: O(1) + * + **/ + claim: AugmentedSubmittable<(dest: AccountId32 | string | Uint8Array, ethereumSignature: PolkadotRuntimeCommonClaimsEcdsaSignature | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, PolkadotRuntimeCommonClaimsEcdsaSignature]>; + /** + * Make a claim to collect your DOTs by signing a statement. + * + * The dispatch origin for this call must be _None_. + * + * Unsigned Validation: + * A call to `claim_attest` is deemed valid if the signature provided matches + * the expected signed message of: + * + * > Ethereum Signed Message: + * > (configured prefix string)(address)(statement) + * + * and `address` matches the `dest` account; the `statement` must match that which is + * expected according to your purchase arrangement. + * + * Parameters: + * - `dest`: The destination account to payout the claim. + * - `ethereum_signature`: The signature of an ethereum signed message + * matching the format described above. + * - `statement`: The identity of the statement which is being attested to in the signature. + * + * + * The weight of this call is invariant over the input parameters. + * Weight includes logic to validate unsigned `claim_attest` call. + * + * Total Complexity: O(1) + * + **/ + claimAttest: AugmentedSubmittable<(dest: AccountId32 | string | Uint8Array, ethereumSignature: PolkadotRuntimeCommonClaimsEcdsaSignature | string | Uint8Array, statement: Bytes | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, PolkadotRuntimeCommonClaimsEcdsaSignature, Bytes]>; + /** + * Mint a new claim to collect DOTs. + * + * The dispatch origin for this call must be _Root_. + * + * Parameters: + * - `who`: The Ethereum address allowed to collect this claim. + * - `value`: The number of DOTs that will be claimed. + * - `vesting_schedule`: An optional vesting schedule for these DOTs. + * + * + * The weight of this call is invariant over the input parameters. + * We assume worst case that both vesting and statement is being inserted. + * + * Total Complexity: O(1) + * + **/ + mintClaim: AugmentedSubmittable<(who: EthereumAddress | string | Uint8Array, value: u128 | AnyNumber | Uint8Array, vestingSchedule: Option> | null | object | string | Uint8Array, statement: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [EthereumAddress, u128, Option>, Option]>; + moveClaim: AugmentedSubmittable<(old: EthereumAddress | string | Uint8Array, updated: EthereumAddress | string | Uint8Array, maybePreclaim: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [EthereumAddress, EthereumAddress, Option]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + configuration: { + /** + * Set the availability period for parachains. + **/ + setChainAvailabilityPeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the acceptance period for an included candidate. + **/ + setCodeRetentionPeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the dispute conclusion by time out period. + **/ + setDisputeConclusionByTimeOutPeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the maximum number of dispute spam slots. + **/ + setDisputeMaxSpamSlots: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the dispute period, in number of sessions to keep for disputes. + **/ + setDisputePeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the dispute post conclusion acceptance period. + **/ + setDisputePostConclusionAcceptancePeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the parachain validator-group rotation frequency + **/ + setGroupRotationFrequency: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of messages allowed in an HRMP channel at once. + **/ + setHrmpChannelMaxCapacity: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum size of a message that could ever be put into an HRMP channel. + **/ + setHrmpChannelMaxMessageSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum total size of messages in bytes allowed in an HRMP channel at once. + **/ + setHrmpChannelMaxTotalSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of outbound HRMP messages can be sent by a candidate. + **/ + setHrmpMaxMessageNumPerCandidate: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of inbound HRMP channels a parachain is allowed to accept. + **/ + setHrmpMaxParachainInboundChannels: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of outbound HRMP channels a parachain is allowed to open. + **/ + setHrmpMaxParachainOutboundChannels: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of inbound HRMP channels a parathread is allowed to accept. + **/ + setHrmpMaxParathreadInboundChannels: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of outbound HRMP channels a parathread is allowed to open. + **/ + setHrmpMaxParathreadOutboundChannels: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the number of sessions after which an HRMP open channel request expires. + **/ + setHrmpOpenRequestTtl: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the amount of funds that the recipient should provide for accepting opening an HRMP + * channel. + **/ + setHrmpRecipientDeposit: AugmentedSubmittable<(updated: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u128]>; + /** + * Sets the amount of funds that the sender should provide for opening an HRMP channel. + **/ + setHrmpSenderDeposit: AugmentedSubmittable<(updated: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u128]>; + /** + * Set the max validation code size for incoming upgrades. + **/ + setMaxCodeSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the critical downward message size. + **/ + setMaxDownwardMessageSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the max head data size for paras. + **/ + setMaxHeadDataSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the max POV block size for incoming upgrades. + **/ + setMaxPovSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of messages that a candidate can contain. + **/ + setMaxUpwardMessageNumPerCandidate: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum size of an upward message that can be sent by a candidate. + **/ + setMaxUpwardMessageSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum items that can present in a upward dispatch queue at once. + **/ + setMaxUpwardQueueCount: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum total size of items that can present in a upward dispatch queue at once. + **/ + setMaxUpwardQueueSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the maximum number of validators to use in parachain consensus. + **/ + setMaxValidators: AugmentedSubmittable<(updated: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Option]>; + /** + * Set the maximum number of validators to assign to any core. + **/ + setMaxValidatorsPerCore: AugmentedSubmittable<(updated: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Option]>; + /** + * Sets the minimum delay between announcing the upgrade block for a parachain until the + * upgrade taking place. + **/ + setMinimumValidationUpgradeDelay: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the total number of delay tranches. + **/ + setNDelayTranches: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the number of validators needed to approve a block. + **/ + setNeededApprovals: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the no show slots, in number of number of consensus slots. + * Must be at least 1. + **/ + setNoShowSlots: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the number of parathread execution cores. + **/ + setParathreadCores: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the number of retries for a particular parathread. + **/ + setParathreadRetries: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Enable or disable PVF pre-checking. Consult the field documentation prior executing. + **/ + setPvfCheckingEnabled: AugmentedSubmittable<(updated: bool | boolean | Uint8Array) => SubmittableExtrinsic, [bool]>; + /** + * Set the number of session changes after which a PVF pre-checking voting is rejected. + **/ + setPvfVotingTtl: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the number of samples to do of the `RelayVRFModulo` approval assignment criterion. + **/ + setRelayVrfModuloSamples: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the scheduling lookahead, in expected number of blocks at peak throughput. + **/ + setSchedulingLookahead: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the availability period for parathreads. + **/ + setThreadAvailabilityPeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum amount of weight any individual upward message may consume. + **/ + setUmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64]>; + /** + * Sets the soft limit for the phase of dispatching dispatchable upward messages. + **/ + setUmpServiceTotalWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64]>; + /** + * Set the validation upgrade delay. + **/ + setValidationUpgradeDelay: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the validation upgrade frequency. + **/ + setValidationUpgradeFrequency: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the zeroth delay tranche width. + **/ + setZerothDelayTrancheWidth: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + council: { + /** + * Close a vote that is either approved, disapproved or whose voting period has ended. + * + * May be called by any signed account in order to finish voting and close the proposal. + * + * If called before the end of the voting period it will only close the vote if it is + * has enough votes to be approved or disapproved. + * + * If called after the end of the voting period abstentions are counted as rejections + * unless there is a prime member set and the prime member cast an approval. + * + * If the close operation completes successfully with disapproval, the transaction fee will + * be waived. Otherwise execution of the approved operation will be charged to the caller. + * + * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed + * proposal. + * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via + * `storage::read` so it is `size_of::() == 4` larger than the pure length. + * + * # + * ## Weight + * - `O(B + M + P1 + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - `P1` is the complexity of `proposal` preimage. + * - `P2` is proposal-count (code-bounded) + * - DB: + * - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`) + * - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec + * `O(P2)`) + * - any mutations done while executing `proposal` (`P1`) + * - up to 3 events + * # + **/ + close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, proposalWeightBound: Compact | AnyNumber | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact, Compact, Compact]>; + /** + * Disapprove a proposal, close, and remove it from the system, regardless of its current + * state. + * + * Must be called by the Root origin. + * + * Parameters: + * * `proposal_hash`: The hash of the proposal that should be disapproved. + * + * # + * Complexity: O(P) where P is the number of max proposals + * DB Weight: + * * Reads: Proposals + * * Writes: Voting, Proposals, ProposalOf + * # + **/ + disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Dispatch a proposal from a member using the `Member` origin. + * + * Origin must be a member of the collective. + * + * # + * ## Weight + * - `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching + * `proposal` + * - DB: 1 read (codec `O(M)`) + DB access of `proposal` + * - 1 event + * # + **/ + execute: AugmentedSubmittable<(proposal: Call | { callIndex?: any; args?: any } | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Call, Compact]>; + /** + * Add a new proposal to either be voted on or executed directly. + * + * Requires the sender to be member. + * + * `threshold` determines whether `proposal` is executed directly (`threshold < 2`) + * or put up for voting. + * + * # + * ## Weight + * - `O(B + M + P1)` or `O(B + M + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - branching is influenced by `threshold` where: + * - `P1` is proposal execution complexity (`threshold < 2`) + * - `P2` is proposals-count (code-bounded) (`threshold >= 2`) + * - DB: + * - 1 storage read `is_member` (codec `O(M)`) + * - 1 storage read `ProposalOf::contains_key` (codec `O(1)`) + * - DB accesses influenced by `threshold`: + * - EITHER storage accesses done by `proposal` (`threshold < 2`) + * - OR proposal insertion (`threshold <= 2`) + * - 1 storage mutation `Proposals` (codec `O(P2)`) + * - 1 storage mutation `ProposalCount` (codec `O(1)`) + * - 1 storage write `ProposalOf` (codec `O(B)`) + * - 1 storage write `Voting` (codec `O(M)`) + * - 1 event + * # + **/ + propose: AugmentedSubmittable<(threshold: Compact | AnyNumber | Uint8Array, proposal: Call | { callIndex?: any; args?: any } | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Call, Compact]>; + /** + * Set the collective's membership. + * + * - `new_members`: The new member list. Be nice to the chain and provide it sorted. + * - `prime`: The prime member whose vote sets the default. + * - `old_count`: The upper bound for the previous number of members in storage. Used for + * weight estimation. + * + * Requires root origin. + * + * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but + * the weight estimations rely on it to estimate dispatchable weight. + * + * # WARNING: + * + * The `pallet-collective` can also be managed by logic outside of the pallet through the + * implementation of the trait [`ChangeMembers`]. + * Any call to `set_members` must be careful that the member set doesn't get out of sync + * with other logic managing the member set. + * + * # + * ## Weight + * - `O(MP + N)` where: + * - `M` old-members-count (code- and governance-bounded) + * - `N` new-members-count (code- and governance-bounded) + * - `P` proposals-count (code-bounded) + * - DB: + * - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the + * members + * - 1 storage read (codec `O(P)`) for reading the proposals + * - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal + * - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one + * # + **/ + setMembers: AugmentedSubmittable<(newMembers: Vec | (AccountId32 | string | Uint8Array)[], prime: Option | null | object | string | Uint8Array, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, Option, u32]>; + /** + * Add an aye or nay vote for the sender to the given proposal. + * + * Requires the sender to be a member. + * + * Transaction fees will be waived if the member is voting on any particular proposal + * for the first time and the call is successful. Subsequent vote changes will charge a + * fee. + * # + * ## Weight + * - `O(M)` where `M` is members-count (code- and governance-bounded) + * - DB: + * - 1 storage read `Members` (codec `O(M)`) + * - 1 storage mutation `Voting` (codec `O(M)`) + * - 1 event + * # + **/ + vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic, [H256, Compact, bool]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + crowdloan: { + /** + * Add an optional memo to an existing crowdloan contribution. + * + * Origin must be Signed, and the user must have contributed to the crowdloan. + **/ + addMemo: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array, memo: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + /** + * Contribute to a crowd sale. This will transfer some balance over to fund a parachain + * slot. It will be withdrawable when the crowdloan has ended and the funds are unused. + **/ + contribute: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, value: Compact | AnyNumber | Uint8Array, signature: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Compact, Compact, Option]>; + /** + * Contribute your entire balance to a crowd sale. This will transfer the entire balance of a user over to fund a parachain + * slot. It will be withdrawable when the crowdloan has ended and the funds are unused. + **/ + contributeAll: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, signature: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Compact, Option]>; + /** + * Create a new crowdloaning campaign for a parachain slot with the given lease period range. + * + * This applies a lock to your parachain configuration, ensuring that it cannot be changed + * by the parachain manager. + **/ + create: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, cap: Compact | AnyNumber | Uint8Array, firstPeriod: Compact | AnyNumber | Uint8Array, lastPeriod: Compact | AnyNumber | Uint8Array, end: Compact | AnyNumber | Uint8Array, verifier: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Compact, Compact, Compact, Compact, Compact, Option]>; + /** + * Remove a fund after the retirement period has ended and all funds have been returned. + **/ + dissolve: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Edit the configuration for an in-progress crowdloan. + * + * Can only be called by Root origin. + **/ + edit: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, cap: Compact | AnyNumber | Uint8Array, firstPeriod: Compact | AnyNumber | Uint8Array, lastPeriod: Compact | AnyNumber | Uint8Array, end: Compact | AnyNumber | Uint8Array, verifier: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Compact, Compact, Compact, Compact, Compact, Option]>; + /** + * Poke the fund into `NewRaise` + * + * Origin must be Signed, and the fund has non-zero raise. + **/ + poke: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Automatically refund contributors of an ended crowdloan. + * Due to weight restrictions, this function may need to be called multiple + * times to fully refund all users. We will refund `RemoveKeysLimit` users at a time. + * + * Origin must be signed, but can come from anyone. + **/ + refund: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Withdraw full balance of a specific contributor. + * + * Origin must be signed, but can come from anyone. + * + * The fund must be either in, or ready for, retirement. For a fund to be *in* retirement, then the retirement + * flag must be set. For a fund to be ready for retirement, then: + * - it must not already be in retirement; + * - the amount of raised funds must be bigger than the _free_ balance of the account; + * - and either: + * - the block number must be at least `end`; or + * - the current lease period must be greater than the fund's `last_period`. + * + * In this case, the fund's retirement flag is set and its `end` is reset to the current block + * number. + * + * - `who`: The account whose contribution should be withdrawn. + * - `index`: The parachain to whose crowdloan the contribution was made. + **/ + withdraw: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + democracy: { + /** + * 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: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, maybeRefIndex: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [H256, Option]>; + /** + * 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()` + **/ + cancelProposal: AugmentedSubmittable<(propIndex: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Cancel a proposal queued for enactment. + * + * The dispatch origin of this call must be _Root_. + * + * - `which`: The index of the referendum to cancel. + * + * Weight: `O(D)` where `D` is the items in the dispatch queue. Weighted as `D = 10`. + **/ + cancelQueued: AugmentedSubmittable<(which: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Remove a referendum. + * + * The dispatch origin of this call must be _Root_. + * + * - `ref_index`: The index of the referendum to cancel. + * + * # Weight: `O(1)`. + **/ + cancelReferendum: AugmentedSubmittable<(refIndex: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Clears all public proposals. + * + * The dispatch origin of this call must be _Root_. + * + * Weight: `O(1)`. + **/ + clearPublicProposals: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * 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: AugmentedSubmittable<(to: AccountId32 | string | Uint8Array, conviction: PalletDemocracyConviction | 'None' | 'Locked1x' | 'Locked2x' | 'Locked3x' | 'Locked4x' | 'Locked5x' | 'Locked6x' | number | Uint8Array, balance: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, PalletDemocracyConviction, u128]>; + /** + * 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)`. + **/ + emergencyCancel: AugmentedSubmittable<(refIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Enact a proposal from a referendum. For now we just make the weight be the maximum. + **/ + enactProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, u32]>; + /** + * 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. + * + * Weight: `O(V)` with V number of vetoers in the blacklist of proposal. + * Decoding vec of length V. Charged as maximum + **/ + externalPropose: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * 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)` + **/ + externalProposeDefault: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * 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)` + **/ + externalProposeMajority: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * 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 + * `FastTrackVotingPeriod` if too low. + * - `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)` + **/ + fastTrack: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, votingPeriod: u32 | AnyNumber | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, u32, u32]>; + /** + * Register the preimage for an upcoming proposal. This requires the proposal to be + * in the dispatch queue. No deposit is needed. When this call is successful, i.e. + * the preimage has not been uploaded before and matches some imminent proposal, + * no fee is paid. + * + * The dispatch origin of this call must be _Signed_. + * + * - `encoded_proposal`: The preimage of a proposal. + * + * Emits `PreimageNoted`. + * + * Weight: `O(E)` with E size of `encoded_proposal` (protected by a required deposit). + **/ + noteImminentPreimage: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Same as `note_imminent_preimage` but origin is `OperationalPreimageOrigin`. + **/ + noteImminentPreimageOperational: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Register the preimage for an upcoming proposal. This doesn't require the proposal to be + * in the dispatch queue but does require a deposit, returned once enacted. + * + * The dispatch origin of this call must be _Signed_. + * + * - `encoded_proposal`: The preimage of a proposal. + * + * Emits `PreimageNoted`. + * + * Weight: `O(E)` with E size of `encoded_proposal` (protected by a required deposit). + **/ + notePreimage: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Same as `note_preimage` but origin is `OperationalPreimageOrigin`. + **/ + notePreimageOperational: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * 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`. + * + * Weight: `O(p)` + **/ + propose: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact]>; + /** + * Remove an expired proposal preimage and collect the deposit. + * + * The dispatch origin of this call must be _Signed_. + * + * - `proposal_hash`: The preimage hash of a proposal. + * - `proposal_length_upper_bound`: an upper bound on length of the proposal. Extrinsic is + * weighted according to this value with no refund. + * + * This will only work after `VotingPeriod` blocks from the time that the preimage was + * noted, if it's the same account doing it. If it's a different account, then it'll only + * work an additional `EnactmentPeriod` later. + * + * Emits `PreimageReaped`. + * + * Weight: `O(D)` where D is length of proposal. + **/ + reapPreimage: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, proposalLenUpperBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact]>; + /** + * 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. + **/ + removeOtherVote: AugmentedSubmittable<(target: AccountId32 | string | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * 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. + **/ + removeVote: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * 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. + * - `seconds_upper_bound`: an upper bound on the current number of seconds on this + * proposal. Extrinsic is weighted according to this value with no refund. + * + * Weight: `O(S)` where S is the number of seconds a proposal already has. + **/ + second: AugmentedSubmittable<(proposal: Compact | AnyNumber | Uint8Array, secondsUpperBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * 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: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * 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: AugmentedSubmittable<(target: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * 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` + **/ + vetoExternal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * 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. + * + * Weight: `O(R)` where R is the number of referendums the voter has voted on. + **/ + vote: AugmentedSubmittable<(refIndex: Compact | AnyNumber | Uint8Array, vote: PalletDemocracyVoteAccountVote | { Standard: any } | { Split: any } | string | Uint8Array) => SubmittableExtrinsic, [Compact, PalletDemocracyVoteAccountVote]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + dmp: { + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + electionProviderMultiPhase: { + /** + * Set a solution in the queue, to be handed out to the client of this pallet in the next + * call to `ElectionProvider::elect`. + * + * This can only be set by `T::ForceOrigin`, and only when the phase is `Emergency`. + * + * The solution is not checked for any feasibility and is assumed to be trustworthy, as any + * feasibility check itself can in principle cause the election process to fail (due to + * memory/weight constrains). + **/ + setEmergencyElectionResult: AugmentedSubmittable<(supports: Vec> | ([AccountId32 | string | Uint8Array, SpNposElectionsSupport | { total?: any; voters?: any } | string | Uint8Array])[]) => SubmittableExtrinsic, [Vec>]>; + /** + * Set a new value for `MinimumUntrustedScore`. + * + * Dispatch origin must be aligned with `T::ForceOrigin`. + * + * This check can be turned off by setting the value to `None`. + **/ + setMinimumUntrustedScore: AugmentedSubmittable<(maybeNextScore: Option> | null | object | string | Uint8Array) => SubmittableExtrinsic, [Option>]>; + /** + * Submit a solution for the signed phase. + * + * The dispatch origin fo this call must be __signed__. + * + * The solution is potentially queued, based on the claimed score and processed at the end + * of the signed phase. + * + * A deposit is reserved and recorded for the solution. Based on the outcome, the solution + * might be rewarded, slashed, or get all or a part of the deposit back. + * + * # + * Queue size must be provided as witness data. + * # + **/ + submit: AugmentedSubmittable<(rawSolution: PalletElectionProviderMultiPhaseRawSolution | { solution?: any; score?: any; round?: any } | string | Uint8Array, numSignedSubmissions: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [PalletElectionProviderMultiPhaseRawSolution, u32]>; + /** + * Submit a solution for the unsigned phase. + * + * The dispatch origin fo this call must be __none__. + * + * This submission is checked on the fly. Moreover, this unsigned solution is only + * validated when submitted to the pool from the **local** node. Effectively, this means + * that only active validators can submit this transaction when authoring a block (similar + * to an inherent). + * + * To prevent any incorrect solution (and thus wasted time/weight), this transaction will + * panic if the solution submitted by the validator is invalid in any way, effectively + * putting their authoring reward at risk. + * + * No deposit or reward is associated with this submission. + **/ + submitUnsigned: AugmentedSubmittable<(rawSolution: PalletElectionProviderMultiPhaseRawSolution | { solution?: any; score?: any; round?: any } | string | Uint8Array, witness: PalletElectionProviderMultiPhaseSolutionOrSnapshotSize | { voters?: any; targets?: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletElectionProviderMultiPhaseRawSolution, PalletElectionProviderMultiPhaseSolutionOrSnapshotSize]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + gilt: { + /** + * Place a bid for a gilt to be issued. + * + * Origin must be Signed, and account must have at least `amount` in free balance. + * + * - `amount`: The amount of the bid; these funds will be reserved. If the bid is + * successfully elevated into an issued gilt, then these funds will continue to be + * reserved until the gilt expires. Must be at least `MinFreeze`. + * - `duration`: The number of periods for which the funds will be locked if the gilt is + * issued. It will expire only after this period has elapsed after the point of issuance. + * Must be greater than 1 and no more than `QueueCount`. + * + * Complexities: + * - `Queues[duration].len()` (just take max). + **/ + placeBid: AugmentedSubmittable<(amount: Compact | AnyNumber | Uint8Array, duration: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, u32]>; + /** + * Retract a previously placed bid. + * + * Origin must be Signed, and the account should have previously issued a still-active bid + * of `amount` for `duration`. + * + * - `amount`: The amount of the previous bid. + * - `duration`: The duration of the previous bid. + **/ + retractBid: AugmentedSubmittable<(amount: Compact | AnyNumber | Uint8Array, duration: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, u32]>; + /** + * Set target proportion of gilt-funds. + * + * Origin must be `AdminOrigin`. + * + * - `target`: The target proportion of effective issued funds that should be under gilts + * at any one time. + **/ + setTarget: AugmentedSubmittable<(target: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Remove an active but expired gilt. Reserved funds under gilt are freed and balance is + * adjusted to ensure that the funds grow or shrink to maintain the equivalent proportion + * of effective total issued funds. + * + * Origin must be Signed and the account must be the owner of the gilt of the given index. + * + * - `index`: The index of the gilt to be thawed. + **/ + thaw: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + grandpa: { + /** + * Note that the current authority set of the GRANDPA finality gadget has + * stalled. This will trigger a forced authority set change at the beginning + * of the next session, to be enacted `delay` blocks after that. The delay + * should be high enough to safely assume that the block signalling the + * forced change will not be re-orged (e.g. 1000 blocks). The GRANDPA voters + * will start the new authority set using the given finalized block as base. + * Only callable by root. + **/ + noteStalled: AugmentedSubmittable<(delay: u32 | AnyNumber | Uint8Array, bestFinalizedBlockNumber: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + **/ + reportEquivocation: AugmentedSubmittable<(equivocationProof: SpFinalityGrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: SpSessionMembershipProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic, [SpFinalityGrandpaEquivocationProof, SpSessionMembershipProof]>; + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + * + * This extrinsic must be called unsigned and it is expected that only + * block authors will call it (validated in `ValidateUnsigned`), as such + * if the block author is defined it will be defined as the equivocation + * reporter. + **/ + reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: SpFinalityGrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: SpSessionMembershipProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic, [SpFinalityGrandpaEquivocationProof, SpSessionMembershipProof]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + hrmp: { + /** + * This extrinsic triggers the cleanup of all the HRMP storage items that + * a para may have. Normally this happens once per session, but this allows + * you to trigger the cleanup immediately for a specific parachain. + * + * Origin must be Root. + **/ + forceCleanHrmp: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Force process HRMP close channel requests. + * + * If there are pending HRMP close channel requests, you can use this + * function process all of those requests immediately. + **/ + forceProcessHrmpClose: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Force process HRMP open channel requests. + * + * If there are pending HRMP open channel requests, you can use this + * function process all of those requests immediately. + **/ + forceProcessHrmpOpen: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Accept a pending open channel request from the given sender. + * + * The channel will be opened only on the next session boundary. + **/ + hrmpAcceptOpenChannel: AugmentedSubmittable<(sender: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * This cancels a pending open channel request. It can be canceled be either of the sender + * or the recipient for that request. The origin must be either of those. + * + * The cancellation happens immediately. It is not possible to cancel the request if it is + * already accepted. + **/ + hrmpCancelOpenRequest: AugmentedSubmittable<(channelId: PolkadotParachainPrimitivesHrmpChannelId | { sender?: any; recipient?: any } | string | Uint8Array) => SubmittableExtrinsic, [PolkadotParachainPrimitivesHrmpChannelId]>; + /** + * Initiate unilateral closing of a channel. The origin must be either the sender or the + * recipient in the channel being closed. + * + * The closure can only happen on a session change. + **/ + hrmpCloseChannel: AugmentedSubmittable<(channelId: PolkadotParachainPrimitivesHrmpChannelId | { sender?: any; recipient?: any } | string | Uint8Array) => SubmittableExtrinsic, [PolkadotParachainPrimitivesHrmpChannelId]>; + /** + * Initiate opening a channel from a parachain to a given recipient with given channel + * parameters. + * + * - `proposed_max_capacity` - specifies how many messages can be in the channel at once. + * - `proposed_max_message_size` - specifies the maximum size of the messages. + * + * These numbers are a subject to the relay-chain configuration limits. + * + * The channel can be opened only after the recipient confirms it and only on a session + * change. + **/ + hrmpInitOpenChannel: AugmentedSubmittable<(recipient: u32 | AnyNumber | Uint8Array, proposedMaxCapacity: u32 | AnyNumber | Uint8Array, proposedMaxMessageSize: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + identity: { + /** + * Add a registrar to the system. + * + * The dispatch origin for this call must be `T::RegistrarOrigin`. + * + * - `account`: the account of the registrar. + * + * Emits `RegistrarAdded` if successful. + * + * # + * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded). + * - One storage mutation (codec `O(R)`). + * - One event. + * # + **/ + addRegistrar: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Add the given account to the sender's subs. + * + * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated + * to the sender. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * sub identity of `sub`. + **/ + addSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Data]>; + /** + * Cancel a previous request. + * + * Payment: A previously reserved deposit is returned on success. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a + * registered identity. + * + * - `reg_index`: The index of the registrar whose judgement is no longer requested. + * + * Emits `JudgementUnrequested` if successful. + * + * # + * - `O(R + X)`. + * - One balance-reserve operation. + * - One storage mutation `O(R + X)`. + * - One event + * # + **/ + cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Clear an account's identity info and all sub-accounts and return all deposits. + * + * Payment: All reserved balances on the account are returned. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * identity. + * + * Emits `IdentityCleared` if successful. + * + * # + * - `O(R + S + X)` + * - where `R` registrar-count (governance-bounded). + * - where `S` subs-count (hard- and deposit-bounded). + * - where `X` additional-field-count (deposit-bounded and code-bounded). + * - One balance-unreserve operation. + * - `2` storage reads and `S + 2` storage deletions. + * - One event. + * # + **/ + clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Remove an account's identity and sub-account information and slash the deposits. + * + * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by + * `Slash`. Verification request deposits are not returned; they should be cancelled + * manually using `cancel_request`. + * + * The dispatch origin for this call must match `T::ForceOrigin`. + * + * - `target`: the account whose identity the judgement is upon. This must be an account + * with a registered identity. + * + * Emits `IdentityKilled` if successful. + * + * # + * - `O(R + S + X)`. + * - One balance-reserve operation. + * - `S + 2` storage mutations. + * - One event. + * # + **/ + killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress]>; + /** + * Provide a judgement for an account's identity. + * + * The dispatch origin for this call must be _Signed_ and the sender must be the account + * of the registrar whose index is `reg_index`. + * + * - `reg_index`: the index of the registrar whose judgement is being made. + * - `target`: the account whose identity the judgement is upon. This must be an account + * with a registered identity. + * - `judgement`: the judgement of the registrar of index `reg_index` about `target`. + * + * Emits `JudgementGiven` if successful. + * + * # + * - `O(R + X)`. + * - One balance-transfer operation. + * - Up to one account-lookup operation. + * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`. + * - One event. + * # + **/ + provideJudgement: AugmentedSubmittable<(regIndex: Compact | AnyNumber | Uint8Array, target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, judgement: PalletIdentityJudgement | { Unknown: any } | { FeePaid: any } | { Reasonable: any } | { KnownGood: any } | { OutOfDate: any } | { LowQuality: any } | { Erroneous: any } | string | Uint8Array) => SubmittableExtrinsic, [Compact, MultiAddress, PalletIdentityJudgement]>; + /** + * Remove the sender as a sub-account. + * + * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated + * to the sender (*not* the original depositor). + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * super-identity. + * + * NOTE: This should not normally be used, but is provided in the case that the non- + * controller of an account is maliciously registered as a sub-account. + **/ + quitSub: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Remove the given account from the sender's subs. + * + * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated + * to the sender. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * sub identity of `sub`. + **/ + removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress]>; + /** + * Alter the associated name of the given sub-account. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * sub identity of `sub`. + **/ + renameSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Data]>; + /** + * Request a judgement from a registrar. + * + * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement + * given. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a + * registered identity. + * + * - `reg_index`: The index of the registrar whose judgement is requested. + * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as: + * + * ```nocompile + * Self::registrars().get(reg_index).unwrap().fee + * ``` + * + * Emits `JudgementRequested` if successful. + * + * # + * - `O(R + X)`. + * - One balance-reserve operation. + * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`. + * - One event. + * # + **/ + requestJudgement: AugmentedSubmittable<(regIndex: Compact | AnyNumber | Uint8Array, maxFee: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * Change the account associated with a registrar. + * + * The dispatch origin for this call must be _Signed_ and the sender must be the account + * of the registrar whose index is `index`. + * + * - `index`: the index of the registrar whose fee is to be set. + * - `new`: the new account ID. + * + * # + * - `O(R)`. + * - One storage mutation `O(R)`. + * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis) + * # + **/ + setAccountId: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [Compact, AccountId32]>; + /** + * Set the fee required for a judgement to be requested from a registrar. + * + * The dispatch origin for this call must be _Signed_ and the sender must be the account + * of the registrar whose index is `index`. + * + * - `index`: the index of the registrar whose fee is to be set. + * - `fee`: the new fee. + * + * # + * - `O(R)`. + * - One storage mutation `O(R)`. + * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis) + * # + **/ + setFee: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, fee: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * Set the field information for a registrar. + * + * The dispatch origin for this call must be _Signed_ and the sender must be the account + * of the registrar whose index is `index`. + * + * - `index`: the index of the registrar whose fee is to be set. + * - `fields`: the fields that the registrar concerns themselves with. + * + * # + * - `O(R)`. + * - One storage mutation `O(R)`. + * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis) + * # + **/ + setFields: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic, [Compact, PalletIdentityBitFlags]>; + /** + * Set an account's identity information and reserve the appropriate deposit. + * + * If the account already has identity information, the deposit is taken as part payment + * for the new deposit. + * + * The dispatch origin for this call must be _Signed_. + * + * - `info`: The identity information. + * + * Emits `IdentitySet` if successful. + * + * # + * - `O(X + X' + R)` + * - where `X` additional-field-count (deposit-bounded and code-bounded) + * - where `R` judgements-count (registrar-count-bounded) + * - One balance reserve operation. + * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`). + * - One event. + * # + **/ + setIdentity: AugmentedSubmittable<(info: PalletIdentityIdentityInfo | { additional?: any; display?: any; legal?: any; web?: any; riot?: any; email?: any; pgpFingerprint?: any; image?: any; twitter?: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletIdentityIdentityInfo]>; + /** + * Set the sub-accounts of the sender. + * + * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned + * and an amount `SubAccountDeposit` will be reserved for each item in `subs`. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * identity. + * + * - `subs`: The identity's (new) sub-accounts. + * + * # + * - `O(P + S)` + * - where `P` old-subs-count (hard- and deposit-bounded). + * - where `S` subs-count (hard- and deposit-bounded). + * - At most one balance operations. + * - DB: + * - `P + S` storage mutations (codec complexity `O(1)`) + * - One storage read (codec complexity `O(P)`). + * - One storage write (codec complexity `O(S)`). + * - One storage-exists (`IdentityOf::contains_key`). + * # + **/ + setSubs: AugmentedSubmittable<(subs: Vec> | ([AccountId32 | string | Uint8Array, Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array])[]) => SubmittableExtrinsic, [Vec>]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + imOnline: { + /** + * # + * - Complexity: `O(K + E)` where K is length of `Keys` (heartbeat.validators_len) and E is + * length of `heartbeat.network_state.external_address` + * - `O(K)`: decoding of length `K` + * - `O(E)`: decoding/encoding of length `E` + * - DbReads: pallet_session `Validators`, pallet_session `CurrentIndex`, `Keys`, + * `ReceivedHeartbeats` + * - DbWrites: `ReceivedHeartbeats` + * # + **/ + heartbeat: AugmentedSubmittable<(heartbeat: PalletImOnlineHeartbeat | { blockNumber?: any; networkState?: any; sessionIndex?: any; authorityIndex?: any; validatorsLen?: any } | string | Uint8Array, signature: PalletImOnlineSr25519AppSr25519Signature | string | Uint8Array) => SubmittableExtrinsic, [PalletImOnlineHeartbeat, PalletImOnlineSr25519AppSr25519Signature]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + indices: { + /** + * Assign an previously unassigned index. + * + * Payment: `Deposit` is reserved from the sender account. + * + * The dispatch origin for this call must be _Signed_. + * + * - `index`: the index to be claimed. This must not be in use. + * + * Emits `IndexAssigned` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - One reserve operation. + * - One event. + * ------------------- + * - DB Weight: 1 Read/Write (Accounts) + * # + **/ + claim: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Force an index to an account. This doesn't require a deposit. If the index is already + * held, then any deposit is reimbursed to its current owner. + * + * The dispatch origin for this call must be _Root_. + * + * - `index`: the index to be (re-)assigned. + * - `new`: the new owner of the index. This function is a no-op if it is equal to sender. + * - `freeze`: if set to `true`, will freeze the index so it cannot be transferred. + * + * Emits `IndexAssigned` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - Up to one reserve operation. + * - One event. + * ------------------- + * - DB Weight: + * - Reads: Indices Accounts, System Account (original owner) + * - Writes: Indices Accounts, System Account (original owner) + * # + **/ + forceTransfer: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array, index: u32 | AnyNumber | Uint8Array, freeze: bool | boolean | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32, bool]>; + /** + * Free up an index owned by the sender. + * + * Payment: Any previous deposit placed for the index is unreserved in the sender account. + * + * The dispatch origin for this call must be _Signed_ and the sender must own the index. + * + * - `index`: the index to be freed. This must be owned by the sender. + * + * Emits `IndexFreed` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - One reserve operation. + * - One event. + * ------------------- + * - DB Weight: 1 Read/Write (Accounts) + * # + **/ + free: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Freeze an index so it will always point to the sender account. This consumes the + * deposit. + * + * The dispatch origin for this call must be _Signed_ and the signing account must have a + * non-frozen account `index`. + * + * - `index`: the index to be frozen in place. + * + * Emits `IndexFrozen` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - Up to one slash operation. + * - One event. + * ------------------- + * - DB Weight: 1 Read/Write (Accounts) + * # + **/ + freeze: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Assign an index already owned by the sender to another account. The balance reservation + * is effectively transferred to the new account. + * + * The dispatch origin for this call must be _Signed_. + * + * - `index`: the index to be re-assigned. This must be owned by the sender. + * - `new`: the new owner of the index. This function is a no-op if it is equal to sender. + * + * Emits `IndexAssigned` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - One transfer operation. + * - One event. + * ------------------- + * - DB Weight: + * - Reads: Indices Accounts, System Account (recipient) + * - Writes: Indices Accounts, System Account (recipient) + * # + **/ + transfer: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + initializer: { + /** + * Issue a signal to the consensus engine to forcibly act as though all parachain + * blocks in all relay chain blocks up to and including the given number in the current + * chain are valid and should be finalized. + **/ + forceApprove: AugmentedSubmittable<(upTo: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + multisig: { + /** + * 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. + * + * # + * - `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`. + * ---------------------------------- + * - DB Weight: + * - Read: Multisig Storage, [Caller Account] + * - Write: Multisig Storage, [Caller Account] + * # + **/ + approveAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec | (AccountId32 | string | Uint8Array)[], maybeTimepoint: Option | null | object | string | Uint8Array, callHash: U8aFixed | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u16, Vec, Option, U8aFixed, u64]>; + /** + * 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. + * + * # + * - `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`. + * ------------------------------- + * - DB Weight: + * - Reads: Multisig Storage, [Caller Account], Calls (if `store_call`) + * - Writes: Multisig Storage, [Caller Account], Calls (if `store_call`) + * - Plus Call Weight + * # + **/ + asMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec | (AccountId32 | string | Uint8Array)[], maybeTimepoint: Option | null | object | string | Uint8Array, call: Bytes | string | Uint8Array, storeCall: bool | boolean | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u16, Vec, Option, Bytes, bool, u64]>; + /** + * 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. + * + * # + * O(Z + C) where Z is the length of the call and C its execution weight. + * ------------------------------- + * - DB Weight: None + * - Plus Call Weight + * # + **/ + asMultiThreshold1: AugmentedSubmittable<(otherSignatories: Vec | (AccountId32 | string | Uint8Array)[], call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [Vec, Call]>; + /** + * 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. + * + * # + * - `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. + * ---------------------------------- + * - DB Weight: + * - Read: Multisig Storage, [Caller Account], Refund Account, Calls + * - Write: Multisig Storage, [Caller Account], Refund Account, Calls + * # + **/ + cancelAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec | (AccountId32 | string | Uint8Array)[], timepoint: PalletMultisigTimepoint | { height?: any; index?: any } | string | Uint8Array, callHash: U8aFixed | string | Uint8Array) => SubmittableExtrinsic, [u16, Vec, PalletMultisigTimepoint, U8aFixed]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + paraInclusion: { + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + paraInherent: { + /** + * Enter the paras inherent. This will process bitfields and backed candidates. + **/ + enter: AugmentedSubmittable<(data: PolkadotPrimitivesV1InherentData | { bitfields?: any; backedCandidates?: any; disputes?: any; parentHeader?: any } | string | Uint8Array) => SubmittableExtrinsic, [PolkadotPrimitivesV1InherentData]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + paras: { + /** + * Note a new block head for para within the context of the current block. + **/ + forceNoteNewHead: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, newHead: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + /** + * Put a parachain directly into the next session's action queue. + * We can't queue it any sooner than this without going into the + * initializer... + **/ + forceQueueAction: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Schedule an upgrade as if it was scheduled in the given relay parent block. + **/ + forceScheduleCodeUpgrade: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, newCode: Bytes | string | Uint8Array, relayParentNumber: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, Bytes, u32]>; + /** + * Set the storage for the parachain validation code immediately. + **/ + forceSetCurrentCode: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, newCode: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + /** + * Set the storage for the current parachain head data immediately. + **/ + forceSetCurrentHead: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, newHead: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + /** + * Includes a statement for a PVF pre-checking vote. Potentially, finalizes the vote and + * enacts the results if that was the last vote before achieving the supermajority. + **/ + includePvfCheckStatement: AugmentedSubmittable<(stmt: PolkadotPrimitivesV1PvfCheckStatement | { accept?: any; subject?: any; sessionIndex?: any; validatorIndex?: any } | string | Uint8Array, signature: PolkadotPrimitivesV0ValidatorAppSignature | string | Uint8Array) => SubmittableExtrinsic, [PolkadotPrimitivesV1PvfCheckStatement, PolkadotPrimitivesV0ValidatorAppSignature]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + parasDisputes: { + forceUnfreeze: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + parasShared: { + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + phragmenElection: { + /** + * Clean all voters who are defunct (i.e. they do not serve any purpose at all). The + * deposit of the removed voters are returned. + * + * This is an root function to be used only for cleaning the state. + * + * The dispatch origin of this call must be root. + * + * # + * The total number of voters and those that are defunct must be provided as witness data. + * # + **/ + cleanDefunctVoters: AugmentedSubmittable<(numVoters: u32 | AnyNumber | Uint8Array, numDefunct: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Remove a particular member from the set. This is effective immediately and the bond of + * the outgoing member is slashed. + * + * If a runner-up is available, then the best runner-up will be removed and replaces the + * outgoing member. Otherwise, a new phragmen election is started. + * + * The dispatch origin of this call must be root. + * + * Note that this does not affect the designated block number of the next election. + * + * # + * If we have a replacement, we use a small weight. Else, since this is a root call and + * will go into phragmen, we assume full block for now. + * # + **/ + removeMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, hasReplacement: bool | boolean | Uint8Array) => SubmittableExtrinsic, [MultiAddress, bool]>; + /** + * Remove `origin` as a voter. + * + * This removes the lock and returns the deposit. + * + * The dispatch origin of this call must be signed and be a voter. + **/ + removeVoter: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Renounce one's intention to be a candidate for the next election round. 3 potential + * outcomes exist: + * + * - `origin` is a candidate and not elected in any set. In this case, the deposit is + * unreserved, returned and origin is removed as a candidate. + * - `origin` is a current runner-up. In this case, the deposit is unreserved, returned and + * origin is removed as a runner-up. + * - `origin` is a current member. In this case, the deposit is unreserved and origin is + * removed as a member, consequently not being a candidate for the next round anymore. + * Similar to [`remove_member`](Self::remove_member), if replacement runners exists, they + * are immediately used. If the prime is renouncing, then no prime will exist until the + * next round. + * + * The dispatch origin of this call must be signed, and have one of the above roles. + * + * # + * The type of renouncing must be provided as witness data. + * # + **/ + renounceCandidacy: AugmentedSubmittable<(renouncing: PalletElectionsPhragmenRenouncing | { Member: any } | { RunnerUp: any } | { Candidate: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletElectionsPhragmenRenouncing]>; + /** + * Submit oneself for candidacy. A fixed amount of deposit is recorded. + * + * All candidates are wiped at the end of the term. They either become a member/runner-up, + * or leave the system while their deposit is slashed. + * + * The dispatch origin of this call must be signed. + * + * ### Warning + * + * Even if a candidate ends up being a member, they must call [`Call::renounce_candidacy`] + * to get their deposit back. Losing the spot in an election will always lead to a slash. + * + * # + * The number of current candidates must be provided as witness data. + * # + **/ + submitCandidacy: AugmentedSubmittable<(candidateCount: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Vote for a set of candidates for the upcoming round of election. This can be called to + * set the initial votes, or update already existing votes. + * + * Upon initial voting, `value` units of `who`'s balance is locked and a deposit amount is + * reserved. The deposit is based on the number of votes and can be updated over time. + * + * The `votes` should: + * - not be empty. + * - be less than the number of possible candidates. Note that all current members and + * runners-up are also automatically candidates for the next round. + * + * If `value` is more than `who`'s total balance, then the maximum of the two is used. + * + * The dispatch origin of this call must be signed. + * + * ### Warning + * + * It is the responsibility of the caller to **NOT** place all of their balance into the + * lock and keep some for further operations. + * + * # + * We assume the maximum weight among all 3 cases: vote_equal, vote_more and vote_less. + * # + **/ + vote: AugmentedSubmittable<(votes: Vec | (AccountId32 | string | Uint8Array)[], value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + preimage: { + /** + * Register a preimage on-chain. + * + * If the preimage was previously requested, no fees or deposits are taken for providing + * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage. + **/ + notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Request a preimage be uploaded to the chain without paying any fees or deposits. + * + * If the preimage requests has already been provided on-chain, we unreserve any deposit + * a user may have paid, and take the control of the preimage out of their hands. + **/ + requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Clear an unrequested preimage from the runtime storage. + **/ + unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Clear a previously made request for a preimage. + * + * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`. + **/ + unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + proxy: { + /** + * 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. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + addProxy: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, proxyType: KusamaRuntimeProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'IdentityJudgement' | 'CancelProxy' | 'Auction' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, KusamaRuntimeProxyType, u32]>; + /** + * 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. + * + * # + * Weight is a function of: + * - A: the number of announcements made. + * - P: the number of proxies the user has. + * # + **/ + announce: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, H256]>; + /** + * 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. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + * TODO: Might be over counting 1 read + **/ + anonymous: AugmentedSubmittable<(proxyType: KusamaRuntimeProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'IdentityJudgement' | 'CancelProxy' | 'Auction' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array, index: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [KusamaRuntimeProxyType, u32, u16]>; + /** + * Removes a previously spawned anonymous 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 + * `anonymous` with corresponding parameters. + * + * - `spawner`: The account that originally called `anonymous` to create this account. + * - `index`: The disambiguation index originally passed to `anonymous`. Probably `0`. + * - `proxy_type`: The proxy type originally passed to `anonymous`. + * - `height`: The height of the chain when the call to `anonymous` was processed. + * - `ext_index`: The extrinsic index in which the call to `anonymous` was processed. + * + * Fails with `NoPermission` in case the caller is not a previously created anonymous + * account whose `anonymous` call has corresponding parameters. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + killAnonymous: AugmentedSubmittable<(spawner: AccountId32 | string | Uint8Array, proxyType: KusamaRuntimeProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'IdentityJudgement' | 'CancelProxy' | 'Auction' | number | Uint8Array, index: u16 | AnyNumber | Uint8Array, height: Compact | AnyNumber | Uint8Array, extIndex: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, KusamaRuntimeProxyType, u16, Compact, Compact]>; + /** + * Dispatch the given `call` from an account that the sender is authorised 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. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + proxy: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, forceProxyType: Option | null | object | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, Option, Call]>; + /** + * 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. + * + * # + * Weight is a function of: + * - A: the number of announcements made. + * - P: the number of proxies the user has. + * # + **/ + proxyAnnounced: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, real: AccountId32 | string | Uint8Array, forceProxyType: Option | null | object | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32, Option, Call]>; + /** + * 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. + * + * # + * Weight is a function of: + * - A: the number of announcements made. + * - P: the number of proxies the user has. + * # + **/ + rejectAnnouncement: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, H256]>; + /** + * 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. + * + * # + * Weight is a function of: + * - A: the number of announcements made. + * - P: the number of proxies the user has. + * # + **/ + removeAnnouncement: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, H256]>; + /** + * 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 `anonymous`, however if done, then + * the unreserved fees will be inaccessible. **All access to this account will be lost.** + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + removeProxies: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * 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. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + removeProxy: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, proxyType: KusamaRuntimeProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'IdentityJudgement' | 'CancelProxy' | 'Auction' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, KusamaRuntimeProxyType, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + recovery: { + /** + * Send a call through a recovered account. + * + * The dispatch origin for this call must be _Signed_ and registered to + * be able to make calls on behalf of the recovered account. + * + * Parameters: + * - `account`: The recovered account you want to make a call on-behalf-of. + * - `call`: The call you want to make with the recovered account. + * + * # + * - The weight of the `call` + 10,000. + * - One storage lookup to check account is recovered by `who`. O(1) + * # + **/ + asRecovered: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, Call]>; + /** + * Cancel the ability to use `as_recovered` for `account`. + * + * The dispatch origin for this call must be _Signed_ and registered to + * be able to make calls on behalf of the recovered account. + * + * Parameters: + * - `account`: The recovered account you are able to call on-behalf-of. + * + * # + * - One storage mutation to check account is recovered by `who`. O(1) + * # + **/ + cancelRecovered: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Allow a successful rescuer to claim their recovered account. + * + * The dispatch origin for this call must be _Signed_ and must be a "rescuer" + * who has successfully completed the account recovery process: collected + * `threshold` or more vouches, waited `delay_period` blocks since initiation. + * + * Parameters: + * - `account`: The lost account that you want to claim has been successfully recovered by + * you. + * + * # + * Key: F (len of friends in config), V (len of vouching friends) + * - One storage read to get the recovery configuration. O(1), Codec O(F) + * - One storage read to get the active recovery process. O(1), Codec O(V) + * - One storage read to get the current block number. O(1) + * - One storage write. O(1), Codec O(V). + * - One event. + * + * Total Complexity: O(F + V) + * # + **/ + claimRecovery: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * As the controller of a recoverable account, close an active recovery + * process for your account. + * + * Payment: By calling this function, the recoverable account will receive + * the recovery deposit `RecoveryDeposit` placed by the rescuer. + * + * The dispatch origin for this call must be _Signed_ and must be a + * recoverable account with an active recovery process for it. + * + * Parameters: + * - `rescuer`: The account trying to rescue this recoverable account. + * + * # + * Key: V (len of vouching friends) + * - One storage read/remove to get the active recovery process. O(1), Codec O(V) + * - One balance call to repatriate reserved. O(X) + * - One event. + * + * Total Complexity: O(V + X) + * # + **/ + closeRecovery: AugmentedSubmittable<(rescuer: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Create a recovery configuration for your account. This makes your account recoverable. + * + * Payment: `ConfigDepositBase` + `FriendDepositFactor` * #_of_friends balance + * will be reserved for storing the recovery configuration. This deposit is returned + * in full when the user calls `remove_recovery`. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `friends`: A list of friends you trust to vouch for recovery attempts. Should be + * ordered and contain no duplicate values. + * - `threshold`: The number of friends that must vouch for a recovery attempt before the + * account can be recovered. Should be less than or equal to the length of the list of + * friends. + * - `delay_period`: The number of blocks after a recovery attempt is initialized that + * needs to pass before the account can be recovered. + * + * # + * - Key: F (len of friends) + * - One storage read to check that account is not already recoverable. O(1). + * - A check that the friends list is sorted and unique. O(F) + * - One currency reserve operation. O(X) + * - One storage write. O(1). Codec O(F). + * - One event. + * + * Total Complexity: O(F + X) + * # + **/ + createRecovery: AugmentedSubmittable<(friends: Vec | (AccountId32 | string | Uint8Array)[], threshold: u16 | AnyNumber | Uint8Array, delayPeriod: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, u16, u32]>; + /** + * Initiate the process for recovering a recoverable account. + * + * Payment: `RecoveryDeposit` balance will be reserved for initiating the + * recovery process. This deposit will always be repatriated to the account + * trying to be recovered. See `close_recovery`. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `account`: The lost account that you want to recover. This account needs to be + * recoverable (i.e. have a recovery configuration). + * + * # + * - One storage read to check that account is recoverable. O(F) + * - One storage read to check that this recovery process hasn't already started. O(1) + * - One currency reserve operation. O(X) + * - One storage read to get the current block number. O(1) + * - One storage write. O(1). + * - One event. + * + * Total Complexity: O(F + X) + * # + **/ + initiateRecovery: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Remove the recovery process for your account. Recovered accounts are still accessible. + * + * NOTE: The user must make sure to call `close_recovery` on all active + * recovery attempts before calling this function else it will fail. + * + * Payment: By calling this function the recoverable account will unreserve + * their recovery configuration deposit. + * (`ConfigDepositBase` + `FriendDepositFactor` * #_of_friends) + * + * The dispatch origin for this call must be _Signed_ and must be a + * recoverable account (i.e. has a recovery configuration). + * + * # + * Key: F (len of friends) + * - One storage read to get the prefix iterator for active recoveries. O(1) + * - One storage read/remove to get the recovery configuration. O(1), Codec O(F) + * - One balance call to unreserved. O(X) + * - One event. + * + * Total Complexity: O(F + X) + * # + **/ + removeRecovery: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Allow ROOT to bypass the recovery process and set an a rescuer account + * for a lost account directly. + * + * The dispatch origin for this call must be _ROOT_. + * + * Parameters: + * - `lost`: The "lost account" to be recovered. + * - `rescuer`: The "rescuer account" which can call as the lost account. + * + * # + * - One storage write O(1) + * - One event + * # + **/ + setRecovered: AugmentedSubmittable<(lost: AccountId32 | string | Uint8Array, rescuer: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32]>; + /** + * Allow a "friend" of a recoverable account to vouch for an active recovery + * process for that account. + * + * The dispatch origin for this call must be _Signed_ and must be a "friend" + * for the recoverable account. + * + * Parameters: + * - `lost`: The lost account that you want to recover. + * - `rescuer`: The account trying to rescue the lost account that you want to vouch for. + * + * The combination of these two parameters must point to an active recovery + * process. + * + * # + * Key: F (len of friends in config), V (len of vouching friends) + * - One storage read to get the recovery configuration. O(1), Codec O(F) + * - One storage read to get the active recovery process. O(1), Codec O(V) + * - One binary search to confirm caller is a friend. O(logF) + * - One binary search to confirm caller has not already vouched. O(logV) + * - One storage write. O(1), Codec O(V). + * - One event. + * + * Total Complexity: O(F + logF + V + logV) + * # + **/ + vouchRecovery: AugmentedSubmittable<(lost: AccountId32 | string | Uint8Array, rescuer: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + registrar: { + /** + * Deregister a Para Id, freeing all data and returning any deposit. + * + * The caller must be Root, the `para` owner, or the `para` itself. The para must be a parathread. + **/ + deregister: AugmentedSubmittable<(id: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Force the registration of a Para Id on the relay chain. + * + * This function must be called by a Root origin. + * + * The deposit taken can be specified for this registration. Any `ParaId` + * can be registered, including sub-1000 IDs which are System Parachains. + **/ + forceRegister: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, deposit: u128 | AnyNumber | Uint8Array, id: u32 | AnyNumber | Uint8Array, genesisHead: Bytes | string | Uint8Array, validationCode: Bytes | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, u128, u32, Bytes, Bytes]>; + /** + * Remove a manager lock from a para. This will allow the manager of a + * previously locked para to deregister or swap a para without using governance. + * + * Can only be called by the Root origin. + **/ + forceRemoveLock: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Register head data and validation code for a reserved Para Id. + * + * ## Arguments + * - `origin`: Must be called by a `Signed` origin. + * - `id`: The para ID. Must be owned/managed by the `origin` signing account. + * - `genesis_head`: The genesis head data of the parachain/thread. + * - `validation_code`: The initial validation code of the parachain/thread. + * + * ## Deposits/Fees + * The origin signed account must reserve a corresponding deposit for the registration. Anything already + * reserved previously for this para ID is accounted for. + * + * ## Events + * The `Registered` event is emitted in case of success. + **/ + register: AugmentedSubmittable<(id: u32 | AnyNumber | Uint8Array, genesisHead: Bytes | string | Uint8Array, validationCode: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes, Bytes]>; + /** + * Reserve a Para Id on the relay chain. + * + * This function will reserve a new Para Id to be owned/managed by the origin account. + * The origin account is able to register head data and validation code using `register` to create + * a parathread. Using the Slots pallet, a parathread can then be upgraded to get a parachain slot. + * + * ## Arguments + * - `origin`: Must be called by a `Signed` origin. Becomes the manager/owner of the new para ID. + * + * ## Deposits/Fees + * The origin must reserve a deposit of `ParaDeposit` for the registration. + * + * ## Events + * The `Reserved` event is emitted in case of success, which provides the ID reserved for use. + **/ + reserve: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Swap a parachain with another parachain or parathread. + * + * The origin must be Root, the `para` owner, or the `para` itself. + * + * The swap will happen only if there is already an opposite swap pending. If there is not, + * the swap will be stored in the pending swaps map, ready for a later confirmatory swap. + * + * The `ParaId`s remain mapped to the same head data and code so external code can rely on + * `ParaId` to be a long-term identifier of a notional "parachain". However, their + * scheduling info (i.e. whether they're a parathread or parachain), auction information + * and the auction deposit are switched. + **/ + swap: AugmentedSubmittable<(id: u32 | AnyNumber | Uint8Array, other: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + scheduler: { + /** + * Cancel an anonymously scheduled task. + **/ + cancel: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Cancel a named scheduled task. + **/ + cancelNamed: AugmentedSubmittable<(id: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Anonymously schedule a task. + **/ + schedule: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, Option>, u8, FrameSupportScheduleMaybeHashed]>; + /** + * Anonymously schedule a task after a delay. + * + * # + * Same as [`schedule`]. + * # + **/ + scheduleAfter: AugmentedSubmittable<(after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, Option>, u8, FrameSupportScheduleMaybeHashed]>; + /** + * Schedule a named task. + **/ + scheduleNamed: AugmentedSubmittable<(id: Bytes | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [Bytes, u32, Option>, u8, FrameSupportScheduleMaybeHashed]>; + /** + * Schedule a named task after a delay. + * + * # + * Same as [`schedule_named`](Self::schedule_named). + * # + **/ + scheduleNamedAfter: AugmentedSubmittable<(id: Bytes | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [Bytes, u32, Option>, u8, FrameSupportScheduleMaybeHashed]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + session: { + /** + * Removes any session key(s) of the function caller. + * + * This doesn't take effect until the next session. + * + * The dispatch origin of this function must be Signed and the account must be either be + * convertible to a validator ID using the chain's typical addressing system (this usually + * means being a controller account) or directly convertible into a validator ID (which + * usually means being a stash account). + * + * # + * - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length + * of `T::Keys::key_ids()` which is fixed. + * - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account` + * - DbWrites: `NextKeys`, `origin account` + * - DbWrites per key id: `KeyOwner` + * # + **/ + purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Sets the session key(s) of the function caller to `keys`. + * Allows an account to set its session key prior to becoming a validator. + * This doesn't take effect until the next session. + * + * The dispatch origin of this function must be signed. + * + * # + * - Complexity: `O(1)`. Actual cost depends on the number of length of + * `T::Keys::key_ids()` which is fixed. + * - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys` + * - DbWrites: `origin account`, `NextKeys` + * - DbReads per key id: `KeyOwner` + * - DbWrites per key id: `KeyOwner` + * # + **/ + setKeys: AugmentedSubmittable<(keys: KusamaRuntimeSessionKeys | { grandpa?: any; babe?: any; imOnline?: any; paraValidator?: any; paraAssignment?: any; authorityDiscovery?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic, [KusamaRuntimeSessionKeys, Bytes]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + slots: { + /** + * Clear all leases for a Para Id, refunding any deposits back to the original owners. + * + * The dispatch origin for this call must match `T::ForceOrigin`. + **/ + clearAllLeases: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Just a connect into the `lease_out` call, in case Root wants to force some lease to happen + * independently of any other on-chain mechanism to use it. + * + * The dispatch origin for this call must match `T::ForceOrigin`. + **/ + forceLease: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, leaser: AccountId32 | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, periodBegin: u32 | AnyNumber | Uint8Array, periodCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, AccountId32, u128, u32, u32]>; + /** + * Try to onboard a parachain that has a lease for the current lease period. + * + * This function can be useful if there was some state issue with a para that should + * have onboarded, but was unable to. As long as they have a lease period, we can + * let them onboard from here. + * + * Origin must be signed, but can be called by anyone. + **/ + triggerOnboard: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + society: { + /** + * A user outside of the society can make a bid for entry. + * + * Payment: `CandidateDeposit` will be reserved for making a bid. It is returned + * when the bid becomes a member, or if the bid calls `unbid`. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `value`: A one time payment the bid would like to receive when joining the society. + * + * # + * Key: B (len of bids), C (len of candidates), M (len of members), X (balance reserve) + * - Storage Reads: + * - One storage read to check for suspended candidate. O(1) + * - One storage read to check for suspended member. O(1) + * - One storage read to retrieve all current bids. O(B) + * - One storage read to retrieve all current candidates. O(C) + * - One storage read to retrieve all members. O(M) + * - Storage Writes: + * - One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization + * w/ read) + * - Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1) + * - Notable Computation: + * - O(B + C + log M) search to check user is not already a part of society. + * - O(log B) search to insert the new bid sorted. + * - External Pallet Operations: + * - One balance reserve operation. O(X) + * - Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT. + * - Events: + * - One event for new bid. + * - Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT. + * + * Total Complexity: O(M + B + C + logM + logB + X) + * # + **/ + bid: AugmentedSubmittable<(value: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u128]>; + /** + * As a member, vote on the defender. + * + * The dispatch origin for this call must be _Signed_ and a member. + * + * Parameters: + * - `approve`: A boolean which says if the candidate should be + * approved (`true`) or rejected (`false`). + * + * # + * - Key: M (len of members) + * - One storage read O(M) and O(log M) search to check user is a member. + * - One storage write to add vote to votes. O(1) + * - One event. + * + * Total Complexity: O(M + logM) + * # + **/ + defenderVote: AugmentedSubmittable<(approve: bool | boolean | Uint8Array) => SubmittableExtrinsic, [bool]>; + /** + * Found the society. + * + * This is done as a discrete action in order to allow for the + * pallet to be included into a running chain and can only be done once. + * + * The dispatch origin for this call must be from the _FounderSetOrigin_. + * + * Parameters: + * - `founder` - The first member and head of the newly founded society. + * - `max_members` - The initial max number of members for the society. + * - `rules` - The rules of this society concerning membership. + * + * # + * - Two storage mutates to set `Head` and `Founder`. O(1) + * - One storage write to add the first member to society. O(1) + * - One event. + * + * Total Complexity: O(1) + * # + **/ + found: AugmentedSubmittable<(founder: AccountId32 | string | Uint8Array, maxMembers: u32 | AnyNumber | Uint8Array, rules: Bytes | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32, Bytes]>; + /** + * Allow suspended judgement origin to make judgement on a suspended candidate. + * + * If the judgement is `Approve`, we add them to society as a member with the appropriate + * payment for joining society. + * + * If the judgement is `Reject`, we either slash the deposit of the bid, giving it back + * to the society treasury, or we ban the voucher from vouching again. + * + * If the judgement is `Rebid`, we put the candidate back in the bid pool and let them go + * through the induction process again. + * + * The dispatch origin for this call must be from the _SuspensionJudgementOrigin_. + * + * Parameters: + * - `who` - The suspended candidate to be judged. + * - `judgement` - `Approve`, `Reject`, or `Rebid`. + * + * # + * Key: B (len of bids), M (len of members), X (balance action) + * - One storage read to check `who` is a suspended candidate. + * - One storage removal of the suspended candidate. + * - Approve Logic + * - One storage read to get the available pot to pay users with. O(1) + * - One storage write to update the available pot. O(1) + * - One storage read to get the current block number. O(1) + * - One storage read to get all members. O(M) + * - Up to one unreserve currency action. + * - Up to two new storage writes to payouts. + * - Up to one storage write with O(log M) binary search to add a member to society. + * - Reject Logic + * - Up to one repatriate reserved currency action. O(X) + * - Up to one storage write to ban the vouching member from vouching again. + * - Rebid Logic + * - Storage mutate with O(log B) binary search to place the user back into bids. + * - Up to one additional event if unvouch takes place. + * - One storage removal. + * - One event for the judgement. + * + * Total Complexity: O(M + logM + B + X) + * # + **/ + judgeSuspendedCandidate: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, judgement: PalletSocietyJudgement | 'Rebid' | 'Reject' | 'Approve' | number | Uint8Array) => SubmittableExtrinsic, [AccountId32, PalletSocietyJudgement]>; + /** + * Allow suspension judgement origin to make judgement on a suspended member. + * + * If a suspended member is forgiven, we simply add them back as a member, not affecting + * any of the existing storage items for that member. + * + * If a suspended member is rejected, remove all associated storage items, including + * their payouts, and remove any vouched bids they currently have. + * + * The dispatch origin for this call must be from the _SuspensionJudgementOrigin_. + * + * Parameters: + * - `who` - The suspended member to be judged. + * - `forgive` - A boolean representing whether the suspension judgement origin forgives + * (`true`) or rejects (`false`) a suspended member. + * + * # + * Key: B (len of bids), M (len of members) + * - One storage read to check `who` is a suspended member. O(1) + * - Up to one storage write O(M) with O(log M) binary search to add a member back to + * society. + * - Up to 3 storage removals O(1) to clean up a removed member. + * - Up to one storage write O(B) with O(B) search to remove vouched bid from bids. + * - Up to one additional event if unvouch takes place. + * - One storage removal. O(1) + * - One event for the judgement. + * + * Total Complexity: O(M + logM + B) + * # + **/ + judgeSuspendedMember: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, forgive: bool | boolean | Uint8Array) => SubmittableExtrinsic, [AccountId32, bool]>; + /** + * Transfer the first matured payout for the sender and remove it from the records. + * + * NOTE: This extrinsic needs to be called multiple times to claim multiple matured + * payouts. + * + * Payment: The member will receive a payment equal to their first matured + * payout to their free balance. + * + * The dispatch origin for this call must be _Signed_ and a member with + * payouts remaining. + * + * # + * Key: M (len of members), P (number of payouts for a particular member) + * - One storage read O(M) and O(log M) search to check signer is a member. + * - One storage read O(P) to get all payouts for a member. + * - One storage read O(1) to get the current block number. + * - One currency transfer call. O(X) + * - One storage write or removal to update the member's payouts. O(P) + * + * Total Complexity: O(M + logM + P + X) + * # + **/ + payout: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Allows root origin to change the maximum number of members in society. + * Max membership count must be greater than 1. + * + * The dispatch origin for this call must be from _ROOT_. + * + * Parameters: + * - `max` - The maximum number of members for the society. + * + * # + * - One storage write to update the max. O(1) + * - One event. + * + * Total Complexity: O(1) + * # + **/ + setMaxMembers: AugmentedSubmittable<(max: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * A bidder can remove their bid for entry into society. + * By doing so, they will have their candidate deposit returned or + * they will unvouch their voucher. + * + * Payment: The bid deposit is unreserved if the user made a bid. + * + * The dispatch origin for this call must be _Signed_ and a bidder. + * + * Parameters: + * - `pos`: Position in the `Bids` vector of the bid who wants to unbid. + * + * # + * Key: B (len of bids), X (balance unreserve) + * - One storage read and write to retrieve and update the bids. O(B) + * - Either one unreserve balance action O(X) or one vouching storage removal. O(1) + * - One event. + * + * Total Complexity: O(B + X) + * # + **/ + unbid: AugmentedSubmittable<(pos: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Annul the founding of the society. + * + * The dispatch origin for this call must be Signed, and the signing account must be both + * the `Founder` and the `Head`. This implies that it may only be done when there is one + * member. + * + * # + * - Two storage reads O(1). + * - Four storage removals O(1). + * - One event. + * + * Total Complexity: O(1) + * # + **/ + unfound: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * As a vouching member, unvouch a bid. This only works while vouched user is + * only a bidder (and not a candidate). + * + * The dispatch origin for this call must be _Signed_ and a vouching member. + * + * Parameters: + * - `pos`: Position in the `Bids` vector of the bid who should be unvouched. + * + * # + * Key: B (len of bids) + * - One storage read O(1) to check the signer is a vouching member. + * - One storage mutate to retrieve and update the bids. O(B) + * - One vouching storage removal. O(1) + * - One event. + * + * Total Complexity: O(B) + * # + **/ + unvouch: AugmentedSubmittable<(pos: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * As a member, vote on a candidate. + * + * The dispatch origin for this call must be _Signed_ and a member. + * + * Parameters: + * - `candidate`: The candidate that the member would like to bid on. + * - `approve`: A boolean which says if the candidate should be approved (`true`) or + * rejected (`false`). + * + * # + * Key: C (len of candidates), M (len of members) + * - One storage read O(M) and O(log M) search to check user is a member. + * - One account lookup. + * - One storage read O(C) and O(C) search to check that user is a candidate. + * - One storage write to add vote to votes. O(1) + * - One event. + * + * Total Complexity: O(M + logM + C) + * # + **/ + vote: AugmentedSubmittable<(candidate: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic, [MultiAddress, bool]>; + /** + * As a member, vouch for someone to join society by placing a bid on their behalf. + * + * There is no deposit required to vouch for a new bid, but a member can only vouch for + * one bid at a time. If the bid becomes a suspended candidate and ultimately rejected by + * the suspension judgement origin, the member will be banned from vouching again. + * + * As a vouching member, you can claim a tip if the candidate is accepted. This tip will + * be paid as a portion of the reward the member will receive for joining the society. + * + * The dispatch origin for this call must be _Signed_ and a member. + * + * Parameters: + * - `who`: The user who you would like to vouch for. + * - `value`: The total reward to be paid between you and the candidate if they become + * a member in the society. + * - `tip`: Your cut of the total `value` payout when the candidate is inducted into + * the society. Tips larger than `value` will be saturated upon payout. + * + * # + * Key: B (len of bids), C (len of candidates), M (len of members) + * - Storage Reads: + * - One storage read to retrieve all members. O(M) + * - One storage read to check member is not already vouching. O(1) + * - One storage read to check for suspended candidate. O(1) + * - One storage read to check for suspended member. O(1) + * - One storage read to retrieve all current bids. O(B) + * - One storage read to retrieve all current candidates. O(C) + * - Storage Writes: + * - One storage write to insert vouching status to the member. O(1) + * - One storage mutate to add a new bid to the vector O(B) (TODO: possible optimization + * w/ read) + * - Up to one storage removal if bid.len() > MAX_BID_COUNT. O(1) + * - Notable Computation: + * - O(log M) search to check sender is a member. + * - O(B + C + log M) search to check user is not already a part of society. + * - O(log B) search to insert the new bid sorted. + * - External Pallet Operations: + * - One balance reserve operation. O(X) + * - Up to one balance unreserve operation if bids.len() > MAX_BID_COUNT. + * - Events: + * - One event for vouch. + * - Up to one event for AutoUnbid if bid.len() > MAX_BID_COUNT. + * + * Total Complexity: O(M + B + C + logM + logB + X) + * # + **/ + vouch: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, value: u128 | AnyNumber | Uint8Array, tip: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u128, u128]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + staking: { + /** + * Take the origin account as a stash and lock up `value` of its balance. `controller` will + * be the account that controls it. + * + * `value` must be more than the `minimum_balance` specified by `T::Currency`. + * + * The dispatch origin for this call must be _Signed_ by the stash account. + * + * Emits `Bonded`. + * # + * - Independent of the arguments. Moderate complexity. + * - O(1). + * - Three extra DB entries. + * + * NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleaned + * unless the `origin` falls below _existential deposit_ and gets removed as dust. + * ------------------ + * # + **/ + bond: AugmentedSubmittable<(controller: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array, payee: PalletStakingRewardDestination | { Staked: any } | { Stash: any } | { Controller: any } | { Account: any } | { None: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact, PalletStakingRewardDestination]>; + /** + * Add some extra amount that have appeared in the stash `free_balance` into the balance up + * for staking. + * + * The dispatch origin for this call must be _Signed_ by the stash, not the controller. + * + * Use this if there are additional funds in your stash account that you wish to bond. + * Unlike [`bond`](Self::bond) or [`unbond`](Self::unbond) this function does not impose + * any limitation on the amount that can be added. + * + * Emits `Bonded`. + * + * # + * - Independent of the arguments. Insignificant complexity. + * - O(1). + * # + **/ + bondExtra: AugmentedSubmittable<(maxAdditional: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Cancel enactment of a deferred slash. + * + * Can be called by the `T::SlashCancelOrigin`. + * + * Parameters: era and indices of the slashes for that era to kill. + * + * # + * Complexity: O(U + S) + * with U unapplied slashes weighted with U=1000 + * and S is the number of slash indices to be canceled. + * - Read: Unapplied Slashes + * - Write: Unapplied Slashes + * # + **/ + cancelDeferredSlash: AugmentedSubmittable<(era: u32 | AnyNumber | Uint8Array, slashIndices: Vec | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [u32, Vec]>; + /** + * Declare no desire to either validate or nominate. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * # + * - Independent of the arguments. Insignificant complexity. + * - Contains one read. + * - Writes are limited to the `origin` account key. + * # + **/ + chill: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Declare a `controller` to stop participating as either a validator or nominator. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_, but can be called by anyone. + * + * If the caller is the same as the controller being targeted, then no further checks are + * enforced, and this function behaves just like `chill`. + * + * If the caller is different than the controller being targeted, the following conditions + * must be met: + * * A `ChillThreshold` must be set and checked which defines how close to the max + * nominators or validators we must reach before users can start chilling one-another. + * * A `MaxNominatorCount` and `MaxValidatorCount` must be set which is used to determine + * how close we are to the threshold. + * * A `MinNominatorBond` and `MinValidatorBond` must be set and checked, which determines + * if this is a person that should be chilled because they have not met the threshold + * bond required. + * + * This can be helpful if bond requirements are updated, and we need to remove old users + * who do not satisfy these requirements. + **/ + chillOther: AugmentedSubmittable<(controller: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Force there to be a new era at the end of the next session. After this, it will be + * reset to normal (non-forced) behaviour. + * + * The dispatch origin must be Root. + * + * # Warning + * + * The election process starts multiple blocks before the end of the era. + * If this is called just before a new era is triggered, the election process may not + * have enough blocks to get a result. + * + * # + * - No arguments. + * - Weight: O(1) + * - Write ForceEra + * # + **/ + forceNewEra: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Force there to be a new era at the end of sessions indefinitely. + * + * The dispatch origin must be Root. + * + * # Warning + * + * The election process starts multiple blocks before the end of the era. + * If this is called just before a new era is triggered, the election process may not + * have enough blocks to get a result. + * + * # + * - Weight: O(1) + * - Write: ForceEra + * # + **/ + forceNewEraAlways: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Force there to be no new eras indefinitely. + * + * The dispatch origin must be Root. + * + * # Warning + * + * The election process starts multiple blocks before the end of the era. + * Thus the election process may be ongoing when this is called. In this case the + * election will continue until the next era is triggered. + * + * # + * - No arguments. + * - Weight: O(1) + * - Write: ForceEra + * # + **/ + forceNoEras: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Force a current staker to become completely unstaked, immediately. + * + * The dispatch origin must be Root. + * + * # + * O(S) where S is the number of slashing spans to be removed + * Reads: Bonded, Slashing Spans, Account, Locks + * Writes: Bonded, Slashing Spans (if S > 0), Ledger, Payee, Validators, Nominators, + * Account, Locks Writes Each: SpanSlash * S + * # + **/ + forceUnstake: AugmentedSubmittable<(stash: AccountId32 | string | Uint8Array, numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * Increments the ideal number of validators. + * + * The dispatch origin must be Root. + * + * # + * Same as [`Self::set_validator_count`]. + * # + **/ + increaseValidatorCount: AugmentedSubmittable<(additional: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Remove the given nominations from the calling validator. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * - `who`: A list of nominator stash accounts who are nominating this validator which + * should no longer be nominating this validator. + * + * Note: Making this call only makes sense if you first set the validator preferences to + * block any further nominations. + **/ + kick: AugmentedSubmittable<(who: Vec | (MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Declare the desire to nominate `targets` for the origin controller. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * # + * - The transaction's complexity is proportional to the size of `targets` (N) + * which is capped at CompactAssignments::LIMIT (MAX_NOMINATIONS). + * - Both the reads and writes follow a similar pattern. + * # + **/ + nominate: AugmentedSubmittable<(targets: Vec | (MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Pay out all the stakers behind a single validator for a single era. + * + * - `validator_stash` is the stash account of the validator. Their nominators, up to + * `T::MaxNominatorRewardedPerValidator`, will also receive their rewards. + * - `era` may be any era between `[current_era - history_depth; current_era]`. + * + * The origin of this call must be _Signed_. Any account can call this function, even if + * it is not one of the stakers. + * + * # + * - Time complexity: at most O(MaxNominatorRewardedPerValidator). + * - Contains a limited number of reads and writes. + * ----------- + * N is the Number of payouts for the validator (including the validator) + * Weight: + * - Reward Destination Staked: O(N) + * - Reward Destination Controller (Creating): O(N) + * + * NOTE: weights are assuming that payouts are made to alive stash account (Staked). + * Paying even a dead controller is cheaper weight-wise. We don't do any refunds here. + * # + **/ + payoutStakers: AugmentedSubmittable<(validatorStash: AccountId32 | string | Uint8Array, era: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * Remove all data structures concerning a staker/stash once it is at a state where it can + * be considered `dust` in the staking system. The requirements are: + * + * 1. the `total_balance` of the stash is below existential deposit. + * 2. or, the `ledger.total` of the stash is below existential deposit. + * + * The former can happen in cases like a slash; the latter when a fully unbonded account + * is still receiving staking rewards in `RewardDestination::Staked`. + * + * It can be called by anyone, as long as `stash` meets the above requirements. + * + * Refunds the transaction fees upon successful execution. + **/ + reapStash: AugmentedSubmittable<(stash: AccountId32 | string | Uint8Array, numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * Rebond a portion of the stash scheduled to be unlocked. + * + * The dispatch origin must be signed by the controller. + * + * # + * - Time complexity: O(L), where L is unlocking chunks + * - Bounded by `MAX_UNLOCKING_CHUNKS`. + * - Storage changes: Can't increase storage, only decrease it. + * # + **/ + rebond: AugmentedSubmittable<(value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Scale up the ideal number of validators by a factor. + * + * The dispatch origin must be Root. + * + * # + * Same as [`Self::set_validator_count`]. + * # + **/ + scaleValidatorCount: AugmentedSubmittable<(factor: Percent | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Percent]>; + /** + * (Re-)set the controller of a stash. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the stash, not the controller. + * + * # + * - Independent of the arguments. Insignificant complexity. + * - Contains a limited number of reads. + * - Writes are limited to the `origin` account key. + * ---------- + * Weight: O(1) + * DB Weight: + * - Read: Bonded, Ledger New Controller, Ledger Old Controller + * - Write: Bonded, Ledger New Controller, Ledger Old Controller + * # + **/ + setController: AugmentedSubmittable<(controller: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress]>; + /** + * Set `HistoryDepth` value. This function will delete any history information + * when `HistoryDepth` is reduced. + * + * Parameters: + * - `new_history_depth`: The new history depth you would like to set. + * - `era_items_deleted`: The number of items that will be deleted by this dispatch. This + * should report all the storage items that will be deleted by clearing old era history. + * Needed to report an accurate weight for the dispatch. Trusted by `Root` to report an + * accurate number. + * + * Origin must be root. + * + * # + * - E: Number of history depths removed, i.e. 10 -> 7 = 3 + * - Weight: O(E) + * - DB Weight: + * - Reads: Current Era, History Depth + * - Writes: History Depth + * - Clear Prefix Each: Era Stakers, EraStakersClipped, ErasValidatorPrefs + * - Writes Each: ErasValidatorReward, ErasRewardPoints, ErasTotalStake, + * ErasStartSessionIndex + * # + **/ + setHistoryDepth: AugmentedSubmittable<(newHistoryDepth: Compact | AnyNumber | Uint8Array, eraItemsDeleted: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * Set the validators who cannot be slashed (if any). + * + * The dispatch origin must be Root. + * + * # + * - O(V) + * - Write: Invulnerables + * # + **/ + setInvulnerables: AugmentedSubmittable<(invulnerables: Vec | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * (Re-)set the payment target for a controller. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * # + * - Independent of the arguments. Insignificant complexity. + * - Contains a limited number of reads. + * - Writes are limited to the `origin` account key. + * --------- + * - Weight: O(1) + * - DB Weight: + * - Read: Ledger + * - Write: Payee + * # + **/ + setPayee: AugmentedSubmittable<(payee: PalletStakingRewardDestination | { Staked: any } | { Stash: any } | { Controller: any } | { Account: any } | { None: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletStakingRewardDestination]>; + /** + * Update the various staking configurations . + * + * * `min_nominator_bond`: The minimum active bond needed to be a nominator. + * * `min_validator_bond`: The minimum active bond needed to be a validator. + * * `max_nominator_count`: The max number of users who can be a nominator at once. When + * set to `None`, no limit is enforced. + * * `max_validator_count`: The max number of users who can be a validator at once. When + * set to `None`, no limit is enforced. + * * `chill_threshold`: The ratio of `max_nominator_count` or `max_validator_count` which + * should be filled in order for the `chill_other` transaction to work. + * * `min_commission`: The minimum amount of commission that each validators must maintain. + * This is checked only upon calling `validate`. Existing validators are not affected. + * + * Origin must be Root to call this function. + * + * NOTE: Existing nominators and validators will not be affected by this update. + * to kick people under the new limits, `chill_other` should be called. + **/ + setStakingConfigs: AugmentedSubmittable<(minNominatorBond: u128 | AnyNumber | Uint8Array, minValidatorBond: u128 | AnyNumber | Uint8Array, maxNominatorCount: Option | null | object | string | Uint8Array, maxValidatorCount: Option | null | object | string | Uint8Array, chillThreshold: Option | null | object | string | Uint8Array, minCommission: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u128, u128, Option, Option, Option, Perbill]>; + /** + * Sets the ideal number of validators. + * + * The dispatch origin must be Root. + * + * # + * Weight: O(1) + * Write: Validator Count + * # + **/ + setValidatorCount: AugmentedSubmittable<(updated: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Schedule a portion of the stash to be unlocked ready for transfer out after the bond + * period ends. If this leaves an amount actively bonded less than + * T::Currency::minimum_balance(), then it is increased to the full amount. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * Once the unlock period is done, you can call `withdraw_unbonded` to actually move + * the funds out of management ready for transfer. + * + * No more than a limited number of unlocking chunks (see `MAX_UNLOCKING_CHUNKS`) + * can co-exists at the same time. In that case, [`Call::withdraw_unbonded`] need + * to be called first to remove some of the chunks (if possible). + * + * If a user encounters the `InsufficientBond` error when calling this extrinsic, + * they should call `chill` first in order to free up their bonded funds. + * + * Emits `Unbonded`. + * + * See also [`Call::withdraw_unbonded`]. + **/ + unbond: AugmentedSubmittable<(value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Declare the desire to validate for the origin controller. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + **/ + validate: AugmentedSubmittable<(prefs: PalletStakingValidatorPrefs | { commission?: any; blocked?: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletStakingValidatorPrefs]>; + /** + * Remove any unlocked chunks from the `unlocking` queue from our management. + * + * This essentially frees up that balance to be used by the stash account to do + * whatever it wants. + * + * The dispatch origin for this call must be _Signed_ by the controller. + * + * Emits `Withdrawn`. + * + * See also [`Call::unbond`]. + * + * # + * Complexity O(S) where S is the number of slashing spans to remove + * NOTE: Weight annotation is the kill scenario, we refund otherwise. + * # + **/ + withdrawUnbonded: AugmentedSubmittable<(numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + system: { + /** + * A dispatch that will fill the block weight up to the given ratio. + **/ + fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Perbill]>; + /** + * Kill all storage items with a key that starts with the given prefix. + * + * **NOTE:** We rely on the Root origin to provide us the number of subkeys under + * the prefix we are removing to accurately calculate the weight of this function. + **/ + killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, u32]>; + /** + * Kill some items from storage. + **/ + killStorage: AugmentedSubmittable<(keys: Vec | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Make some on-chain remark. + * + * # + * - `O(1)` + * # + **/ + remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Make some on-chain remark and emit event. + * + * # + * - `O(b)` where b is the length of the remark. + * - 1 event. + * # + **/ + remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Set the new runtime code. + * + * # + * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code` + * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is + * expensive). + * - 1 storage write (codec `O(C)`). + * - 1 digest item. + * - 1 event. + * The weight of this function is dependent on the runtime, but generally this is very + * expensive. We will treat this as a full block. + * # + **/ + setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Set the new runtime code without doing any checks of the given `code`. + * + * # + * - `O(C)` where `C` length of `code` + * - 1 storage write (codec `O(C)`). + * - 1 digest item. + * - 1 event. + * The weight of this function is dependent on the runtime. We will treat this as a full + * block. # + **/ + setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Set the number of pages in the WebAssembly environment's heap. + **/ + setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64]>; + /** + * Set some items of storage. + **/ + setStorage: AugmentedSubmittable<(items: Vec> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic, [Vec>]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + technicalCommittee: { + /** + * Close a vote that is either approved, disapproved or whose voting period has ended. + * + * May be called by any signed account in order to finish voting and close the proposal. + * + * If called before the end of the voting period it will only close the vote if it is + * has enough votes to be approved or disapproved. + * + * If called after the end of the voting period abstentions are counted as rejections + * unless there is a prime member set and the prime member cast an approval. + * + * If the close operation completes successfully with disapproval, the transaction fee will + * be waived. Otherwise execution of the approved operation will be charged to the caller. + * + * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed + * proposal. + * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via + * `storage::read` so it is `size_of::() == 4` larger than the pure length. + * + * # + * ## Weight + * - `O(B + M + P1 + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - `P1` is the complexity of `proposal` preimage. + * - `P2` is proposal-count (code-bounded) + * - DB: + * - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`) + * - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec + * `O(P2)`) + * - any mutations done while executing `proposal` (`P1`) + * - up to 3 events + * # + **/ + close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, proposalWeightBound: Compact | AnyNumber | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact, Compact, Compact]>; + /** + * Disapprove a proposal, close, and remove it from the system, regardless of its current + * state. + * + * Must be called by the Root origin. + * + * Parameters: + * * `proposal_hash`: The hash of the proposal that should be disapproved. + * + * # + * Complexity: O(P) where P is the number of max proposals + * DB Weight: + * * Reads: Proposals + * * Writes: Voting, Proposals, ProposalOf + * # + **/ + disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Dispatch a proposal from a member using the `Member` origin. + * + * Origin must be a member of the collective. + * + * # + * ## Weight + * - `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching + * `proposal` + * - DB: 1 read (codec `O(M)`) + DB access of `proposal` + * - 1 event + * # + **/ + execute: AugmentedSubmittable<(proposal: Call | { callIndex?: any; args?: any } | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Call, Compact]>; + /** + * Add a new proposal to either be voted on or executed directly. + * + * Requires the sender to be member. + * + * `threshold` determines whether `proposal` is executed directly (`threshold < 2`) + * or put up for voting. + * + * # + * ## Weight + * - `O(B + M + P1)` or `O(B + M + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - branching is influenced by `threshold` where: + * - `P1` is proposal execution complexity (`threshold < 2`) + * - `P2` is proposals-count (code-bounded) (`threshold >= 2`) + * - DB: + * - 1 storage read `is_member` (codec `O(M)`) + * - 1 storage read `ProposalOf::contains_key` (codec `O(1)`) + * - DB accesses influenced by `threshold`: + * - EITHER storage accesses done by `proposal` (`threshold < 2`) + * - OR proposal insertion (`threshold <= 2`) + * - 1 storage mutation `Proposals` (codec `O(P2)`) + * - 1 storage mutation `ProposalCount` (codec `O(1)`) + * - 1 storage write `ProposalOf` (codec `O(B)`) + * - 1 storage write `Voting` (codec `O(M)`) + * - 1 event + * # + **/ + propose: AugmentedSubmittable<(threshold: Compact | AnyNumber | Uint8Array, proposal: Call | { callIndex?: any; args?: any } | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Call, Compact]>; + /** + * Set the collective's membership. + * + * - `new_members`: The new member list. Be nice to the chain and provide it sorted. + * - `prime`: The prime member whose vote sets the default. + * - `old_count`: The upper bound for the previous number of members in storage. Used for + * weight estimation. + * + * Requires root origin. + * + * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but + * the weight estimations rely on it to estimate dispatchable weight. + * + * # WARNING: + * + * The `pallet-collective` can also be managed by logic outside of the pallet through the + * implementation of the trait [`ChangeMembers`]. + * Any call to `set_members` must be careful that the member set doesn't get out of sync + * with other logic managing the member set. + * + * # + * ## Weight + * - `O(MP + N)` where: + * - `M` old-members-count (code- and governance-bounded) + * - `N` new-members-count (code- and governance-bounded) + * - `P` proposals-count (code-bounded) + * - DB: + * - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the + * members + * - 1 storage read (codec `O(P)`) for reading the proposals + * - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal + * - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one + * # + **/ + setMembers: AugmentedSubmittable<(newMembers: Vec | (AccountId32 | string | Uint8Array)[], prime: Option | null | object | string | Uint8Array, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, Option, u32]>; + /** + * Add an aye or nay vote for the sender to the given proposal. + * + * Requires the sender to be a member. + * + * Transaction fees will be waived if the member is voting on any particular proposal + * for the first time and the call is successful. Subsequent vote changes will charge a + * fee. + * # + * ## Weight + * - `O(M)` where `M` is members-count (code- and governance-bounded) + * - DB: + * - 1 storage read `Members` (codec `O(M)`) + * - 1 storage mutation `Voting` (codec `O(M)`) + * - 1 event + * # + **/ + vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic, [H256, Compact, bool]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + technicalMembership: { + /** + * Add a member `who` to the set. + * + * May only be called from `T::AddOrigin`. + **/ + addMember: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Swap out the sending member for some other key `new`. + * + * May only be called from `Signed` origin of a current member. + * + * Prime membership is passed from the origin account to `new`, if extant. + **/ + changeKey: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Remove the prime member if it exists. + * + * May only be called from `T::PrimeOrigin`. + **/ + clearPrime: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Remove a member `who` from the set. + * + * May only be called from `T::RemoveOrigin`. + **/ + removeMember: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Change the membership to a new set, disregarding the existing membership. Be nice and + * pass `members` pre-sorted. + * + * May only be called from `T::ResetOrigin`. + **/ + resetMembers: AugmentedSubmittable<(members: Vec | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Set the prime member. Must be a current member. + * + * May only be called from `T::PrimeOrigin`. + **/ + setPrime: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Swap out one member `remove` for another `add`. + * + * May only be called from `T::SwapOrigin`. + * + * Prime membership is *not* passed from `remove` to `add`, if extant. + **/ + swapMember: AugmentedSubmittable<(remove: AccountId32 | string | Uint8Array, add: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + timestamp: { + /** + * Set the current time. + * + * This call should be invoked exactly once per block. It will panic at the finalization + * phase, if this call hasn't been invoked by that time. + * + * The timestamp should be greater than the previous one by the amount specified by + * `MinimumPeriod`. + * + * The dispatch origin for this call must be `Inherent`. + * + * # + * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`) + * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in + * `on_finalize`) + * - 1 event handler `on_timestamp_set`. Must be `O(1)`. + * # + **/ + set: AugmentedSubmittable<(now: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + tips: { + /** + * Close and payout a tip. + * + * The dispatch origin for this call must be _Signed_. + * + * The tip identified by `hash` must have finished its countdown period. + * + * - `hash`: The identity of the open tip for which a tip value is declared. This is formed + * as the hash of the tuple of the original tip `reason` and the beneficiary account ID. + * + * # + * - Complexity: `O(T)` where `T` is the number of tippers. decoding `Tipper` vec of length + * `T`. `T` is charged as upper bound given by `ContainsLengthBound`. The actual cost + * depends on the implementation of `T::Tippers`. + * - DbReads: `Tips`, `Tippers`, `tip finder` + * - DbWrites: `Reasons`, `Tips`, `Tippers`, `tip finder` + * # + **/ + closeTip: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Report something `reason` that deserves a tip and claim any eventual the finder's fee. + * + * The dispatch origin for this call must be _Signed_. + * + * Payment: `TipReportDepositBase` will be reserved from the origin account, as well as + * `DataDepositPerByte` for each byte in `reason`. + * + * - `reason`: The reason for, or the thing that deserves, the tip; generally this will be + * a UTF-8-encoded URL. + * - `who`: The account which should be credited for the tip. + * + * Emits `NewTip` if successful. + * + * # + * - Complexity: `O(R)` where `R` length of `reason`. + * - encoding and hashing of 'reason' + * - DbReads: `Reasons`, `Tips` + * - DbWrites: `Reasons`, `Tips` + * # + **/ + reportAwesome: AugmentedSubmittable<(reason: Bytes | string | Uint8Array, who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [Bytes, AccountId32]>; + /** + * Retract a prior tip-report from `report_awesome`, and cancel the process of tipping. + * + * If successful, the original deposit will be unreserved. + * + * The dispatch origin for this call must be _Signed_ and the tip identified by `hash` + * must have been reported by the signing account through `report_awesome` (and not + * through `tip_new`). + * + * - `hash`: The identity of the open tip for which a tip value is declared. This is formed + * as the hash of the tuple of the original tip `reason` and the beneficiary account ID. + * + * Emits `TipRetracted` if successful. + * + * # + * - Complexity: `O(1)` + * - Depends on the length of `T::Hash` which is fixed. + * - DbReads: `Tips`, `origin account` + * - DbWrites: `Reasons`, `Tips`, `origin account` + * # + **/ + retractTip: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Remove and slash an already-open tip. + * + * May only be called from `T::RejectOrigin`. + * + * As a result, the finder is slashed and the deposits are lost. + * + * Emits `TipSlashed` if successful. + * + * # + * `T` is charged as upper bound given by `ContainsLengthBound`. + * The actual cost depends on the implementation of `T::Tippers`. + * # + **/ + slashTip: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Declare a tip value for an already-open tip. + * + * The dispatch origin for this call must be _Signed_ and the signing account must be a + * member of the `Tippers` set. + * + * - `hash`: The identity of the open tip for which a tip value is declared. This is formed + * as the hash of the tuple of the hash of the original tip `reason` and the beneficiary + * account ID. + * - `tip_value`: The amount of tip that the sender would like to give. The median tip + * value of active tippers will be given to the `who`. + * + * Emits `TipClosing` if the threshold of tippers has been reached and the countdown period + * has started. + * + * # + * - Complexity: `O(T)` where `T` is the number of tippers. decoding `Tipper` vec of length + * `T`, insert tip and check closing, `T` is charged as upper bound given by + * `ContainsLengthBound`. The actual cost depends on the implementation of `T::Tippers`. + * + * Actually weight could be lower as it depends on how many tips are in `OpenTip` but it + * is weighted as if almost full i.e of length `T-1`. + * - DbReads: `Tippers`, `Tips` + * - DbWrites: `Tips` + * # + **/ + tip: AugmentedSubmittable<(hash: H256 | string | Uint8Array, tipValue: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact]>; + /** + * Give a tip for something new; no finder's fee will be taken. + * + * The dispatch origin for this call must be _Signed_ and the signing account must be a + * member of the `Tippers` set. + * + * - `reason`: The reason for, or the thing that deserves, the tip; generally this will be + * a UTF-8-encoded URL. + * - `who`: The account which should be credited for the tip. + * - `tip_value`: The amount of tip that the sender would like to give. The median tip + * value of active tippers will be given to the `who`. + * + * Emits `NewTip` if successful. + * + * # + * - Complexity: `O(R + T)` where `R` length of `reason`, `T` is the number of tippers. + * - `O(T)`: decoding `Tipper` vec of length `T`. `T` is charged as upper bound given by + * `ContainsLengthBound`. The actual cost depends on the implementation of + * `T::Tippers`. + * - `O(R)`: hashing and encoding of reason of length `R` + * - DbReads: `Tippers`, `Reasons` + * - DbWrites: `Reasons`, `Tips` + * # + **/ + tipNew: AugmentedSubmittable<(reason: Bytes | string | Uint8Array, who: AccountId32 | string | Uint8Array, tipValue: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, AccountId32, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + treasury: { + /** + * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary + * and the original deposit will be returned. + * + * May only be called from `T::ApproveOrigin`. + * + * # + * - Complexity: O(1). + * - DbReads: `Proposals`, `Approvals` + * - DbWrite: `Approvals` + * # + **/ + approveProposal: AugmentedSubmittable<(proposalId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Put forward a suggestion for spending. A deposit proportional to the value + * is reserved and slashed if the proposal is rejected. It is returned once the + * proposal is awarded. + * + * # + * - Complexity: O(1) + * - DbReads: `ProposalCount`, `origin account` + * - DbWrites: `ProposalCount`, `Proposals`, `origin account` + * # + **/ + proposeSpend: AugmentedSubmittable<(value: Compact | AnyNumber | Uint8Array, beneficiary: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [Compact, MultiAddress]>; + /** + * Reject a proposed spend. The original deposit will be slashed. + * + * May only be called from `T::RejectOrigin`. + * + * # + * - Complexity: O(1) + * - DbReads: `Proposals`, `rejected proposer account` + * - DbWrites: `Proposals`, `rejected proposer account` + * # + **/ + rejectProposal: AugmentedSubmittable<(proposalId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + ump: { + /** + * Service a single overweight upward message. + * + * - `origin`: Must pass `ExecuteOverweightOrigin`. + * - `index`: The index of the overweight message to service. + * - `weight_limit`: The amount of weight that message execution may take. + * + * Errors: + * - `UnknownMessageIndex`: Message of `index` is unknown. + * - `WeightOverLimit`: Message execution may use greater than `weight_limit`. + * + * Events: + * - `OverweightServiced`: On success. + **/ + serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64, u64]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + utility: { + /** + * 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_. + **/ + asDerivative: AugmentedSubmittable<(index: u16 | AnyNumber | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [u16, Call]>; + /** + * Send a batch of dispatch calls. + * + * May be called from any origin. + * + * - `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 call 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. + * # + * + * 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: AugmentedSubmittable<(calls: Vec | (Call | { callIndex?: any; args?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * 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. + * + * - `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 call 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. + * # + **/ + batchAll: AugmentedSubmittable<(calls: Vec | (Call | { callIndex?: any; args?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Dispatches a function call with a provided origin. + * + * The dispatch origin for this call must be _Root_. + * + * # + * - O(1). + * - Limited storage reads. + * - One DB write (event). + * - Weight of derivative `call` execution + T::WeightInfo::dispatch_as(). + * # + **/ + dispatchAs: AugmentedSubmittable<(asOrigin: KusamaRuntimeOriginCaller | { system: any } | { Void: any } | { Council: any } | { TechnicalCommittee: any } | { ParachainsOrigin: any } | { XcmPallet: any } | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [KusamaRuntimeOriginCaller, Call]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + vesting: { + /** + * Force a vested transfer. + * + * The dispatch origin for this call must be _Root_. + * + * - `source`: The account whose funds should be transferred. + * - `target`: The account that should be transferred the vested funds. + * - `schedule`: The vesting schedule attached to the transfer. + * + * Emits `VestingCreated`. + * + * NOTE: This will unlock all schedules through the current block. + * + * # + * - `O(1)`. + * - DbWeight: 4 Reads, 4 Writes + * - Reads: Vesting Storage, Balances Locks, Target Account, Source Account + * - Writes: Vesting Storage, Balances Locks, Target Account, Source Account + * # + **/ + forceVestedTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: PalletVestingVestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, MultiAddress, PalletVestingVestingInfo]>; + /** + * Merge two vesting schedules together, creating a new vesting schedule that unlocks over + * the highest possible start and end blocks. If both schedules have already started the + * current block will be used as the schedule start; with the caveat that if one schedule + * is finished by the current block, the other will be treated as the new merged schedule, + * unmodified. + * + * NOTE: If `schedule1_index == schedule2_index` this is a no-op. + * NOTE: This will unlock all schedules through the current block prior to merging. + * NOTE: If both schedules have ended by the current block, no new schedule will be created + * and both will be removed. + * + * Merged schedule attributes: + * - `starting_block`: `MAX(schedule1.starting_block, scheduled2.starting_block, + * current_block)`. + * - `ending_block`: `MAX(schedule1.ending_block, schedule2.ending_block)`. + * - `locked`: `schedule1.locked_at(current_block) + schedule2.locked_at(current_block)`. + * + * The dispatch origin for this call must be _Signed_. + * + * - `schedule1_index`: index of the first schedule to merge. + * - `schedule2_index`: index of the second schedule to merge. + **/ + mergeSchedules: AugmentedSubmittable<(schedule1Index: u32 | AnyNumber | Uint8Array, schedule2Index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Unlock any vested funds of the sender account. + * + * The dispatch origin for this call must be _Signed_ and the sender must have funds still + * locked under this pallet. + * + * Emits either `VestingCompleted` or `VestingUpdated`. + * + * # + * - `O(1)`. + * - DbWeight: 2 Reads, 2 Writes + * - Reads: Vesting Storage, Balances Locks, [Sender Account] + * - Writes: Vesting Storage, Balances Locks, [Sender Account] + * # + **/ + vest: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Create a vested transfer. + * + * The dispatch origin for this call must be _Signed_. + * + * - `target`: The account receiving the vested funds. + * - `schedule`: The vesting schedule attached to the transfer. + * + * Emits `VestingCreated`. + * + * NOTE: This will unlock all schedules through the current block. + * + * # + * - `O(1)`. + * - DbWeight: 3 Reads, 3 Writes + * - Reads: Vesting Storage, Balances Locks, Target Account, [Sender Account] + * - Writes: Vesting Storage, Balances Locks, Target Account, [Sender Account] + * # + **/ + vestedTransfer: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: PalletVestingVestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, PalletVestingVestingInfo]>; + /** + * Unlock any vested funds of a `target` account. + * + * The dispatch origin for this call must be _Signed_. + * + * - `target`: The account whose vested funds should be unlocked. Must have funds still + * locked under this pallet. + * + * Emits either `VestingCompleted` or `VestingUpdated`. + * + * # + * - `O(1)`. + * - DbWeight: 3 Reads, 3 Writes + * - Reads: Vesting Storage, Balances Locks, Target Account + * - Writes: Vesting Storage, Balances Locks, Target Account + * # + **/ + vestOther: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + xcmPallet: { + /** + * 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. + * + * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully + * to completion; only that *some* of it was executed. + **/ + execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [XcmVersionedXcm, u64]>; + /** + * 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 Root. + * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable. + **/ + forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Option]>; + /** + * Ask a location to notify us regarding their XCM version and any changes to it. + * + * - `origin`: Must be Root. + * - `location`: The location to which we should subscribe for XCM version notifications. + **/ + forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation]>; + /** + * Require that a particular destination should no longer notify us regarding any XCM + * version changes. + * + * - `origin`: Must be Root. + * - `location`: The location to which we are currently subscribed for XCM version + * notifications which we no longer desire. + **/ + forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation]>; + /** + * Extoll that a particular destination can be communicated with through a particular + * version of XCM. + * + * - `origin`: Must be Root. + * - `location`: The destination that is being described. + * - `xcm_version`: The latest version of XCM that `location` supports. + **/ + forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [XcmV1MultiLocation, u32]>; + /** + * Transfer some assets from the local chain to the sovereign account of a destination chain and forward + * a notification XCM. + * + * Fee payment on the destination side is made from the first asset listed in the `assets` vector. + * + * - `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` side. + * - `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. + **/ + limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>; + /** + * Teleport some assets from the local chain to some destination chain. + * + * Fee payment on the destination side is made from the first asset listed in the `assets` vector. + * + * - `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. The first item should be the currency used to to pay the fee on the + * `dest` side. May not be empty. + * - `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. + **/ + limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>; + /** + * Transfer some assets from the local chain to the sovereign account of a destination chain and forward + * a notification XCM. + * + * Fee payment on the destination side is made from the first asset listed in the `assets` vector and + * fee-weight is calculated locally and thus remote weights are assumed to be equal to + * local weights. + * + * - `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` side. + * - `fee_asset_item`: The index into `assets` of the item which should be used to pay + * fees. + **/ + reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>; + send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedXcm]>; + /** + * Teleport some assets from the local chain to some destination chain. + * + * Fee payment on the destination side is made from the first asset listed in the `assets` vector and + * fee-weight is calculated locally and thus remote weights are assumed to be equal to + * local weights. + * + * - `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. The first item should be the currency used to to pay the fee on the + * `dest` side. May not be empty. + * - `fee_asset_item`: The index into `assets` of the item which should be used to pay + * fees. + **/ + teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + } // AugmentedSubmittables +} // declare module diff --git a/packages/api-augment/src/polkadot/consts.ts b/packages/api-augment/src/polkadot/consts.ts new file mode 100644 index 0000000000..6073e81659 --- /dev/null +++ b/packages/api-augment/src/polkadot/consts.ts @@ -0,0 +1,768 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; +import type { Bytes, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { Codec } from '@polkadot/types-codec/types'; +import type { Perbill, Percent, Permill } from '@polkadot/types/interfaces/runtime'; +import type { FrameSupportPalletId, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion } from '@polkadot/types/lookup'; + +declare module '@polkadot/api-base/types/consts' { + export interface AugmentedConsts { + auctions: { + /** + * The number of blocks over which an auction may be retroactively ended. + **/ + endingPeriod: u32 & AugmentedConst; + leasePeriodsPerSlot: u32 & AugmentedConst; + /** + * The length of each sample to take during the ending period. + * + * `EndingPeriod` / `SampleLength` = Total # of Samples + **/ + sampleLength: u32 & AugmentedConst; + slotRangeCount: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + authorship: { + /** + * The number of blocks back we should accept uncles. + * This means that we will deal with uncle-parents that are + * `UncleGenerations + 1` before `now`. + **/ + uncleGenerations: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + babe: { + /** + * The amount of time, in slots, that each epoch should last. + * NOTE: Currently it is not possible to change the epoch duration after + * the chain has started. Attempting to do so will brick block production. + **/ + epochDuration: u64 & AugmentedConst; + /** + * The expected average block time at which BABE should be creating + * blocks. Since BABE is probabilistic it is not trivial to figure out + * what the expected average block time should be based on the slot + * duration and the security parameter `c` (where `1 - c` represents + * the probability of a slot being empty). + **/ + expectedBlockTime: u64 & AugmentedConst; + /** + * Max number of authorities allowed + **/ + maxAuthorities: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + bagsList: { + /** + * The list of thresholds separating the various bags. + * + * Ids are separated into unsorted bags according to their vote weight. This specifies the + * thresholds separating the bags. An id's bag is the largest bag for which the id's weight + * is less than or equal to its upper threshold. + * + * When ids are iterated, higher bags are iterated completely before lower bags. This means + * that iteration is _semi-sorted_: ids of higher weight tend to come before ids of lower + * weight, but peer ids within a particular bag are sorted in insertion order. + * + * # Expressing the constant + * + * This constant must be sorted in strictly increasing order. Duplicate items are not + * permitted. + * + * There is an implied upper limit of `VoteWeight::MAX`; that value does not need to be + * specified within the bag. For any two threshold lists, if one ends with + * `VoteWeight::MAX`, the other one does not, and they are otherwise equal, the two lists + * will behave identically. + * + * # Calculation + * + * It is recommended to generate the set of thresholds in a geometric series, such that + * there exists some constant ratio such that `threshold[k + 1] == (threshold[k] * + * constant_ratio).max(threshold[k] + 1)` for all `k`. + * + * The helpers in the `/utils/frame/generate-bags` module can simplify this calculation. + * + * # Examples + * + * - If `BagThresholds::get().is_empty()`, then all ids are put into the same bag, and + * iteration is strictly in insertion order. + * - If `BagThresholds::get().len() == 64`, and the thresholds are determined according to + * the procedure given above, then the constant ratio is equal to 2. + * - If `BagThresholds::get().len() == 200`, and the thresholds are determined according to + * the procedure given above, then the constant ratio is approximately equal to 1.248. + * - If the threshold list begins `[1, 2, 3, ...]`, then an id with weight 0 or 1 will fall + * into bag 0, an id with weight 2 will fall into bag 1, etc. + * + * # Migration + * + * In the event that this list ever changes, a copy of the old bags list must be retained. + * With that `List::migrate` can be called, which will perform the appropriate migration. + **/ + bagThresholds: Vec & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + balances: { + /** + * The minimum amount required to keep an account open. + **/ + existentialDeposit: u128 & AugmentedConst; + /** + * The maximum number of locks that should exist on an account. + * Not strictly enforced, but used for weight estimation. + **/ + maxLocks: u32 & AugmentedConst; + /** + * The maximum number of named reserves that can exist on an account. + **/ + maxReserves: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + bounties: { + /** + * Percentage of the curator fee that will be reserved upfront as deposit for bounty + * curator. + **/ + bountyCuratorDeposit: Permill & AugmentedConst; + /** + * The amount held on deposit for placing a bounty proposal. + **/ + bountyDepositBase: u128 & AugmentedConst; + /** + * The delay period for which a bounty beneficiary need to wait before claim the payout. + **/ + bountyDepositPayoutDelay: u32 & AugmentedConst; + /** + * Bounty duration in blocks. + **/ + bountyUpdatePeriod: u32 & AugmentedConst; + /** + * Minimum value for a bounty. + **/ + bountyValueMinimum: u128 & AugmentedConst; + /** + * The amount held on deposit per byte within the tip report reason or bounty description. + **/ + dataDepositPerByte: u128 & AugmentedConst; + /** + * Maximum acceptable reason length. + * + * Benchmarks depend on this value, be sure to update weights file when changing this value + **/ + maximumReasonLength: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + claims: { + prefix: Bytes & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + crowdloan: { + /** + * The minimum amount that may be contributed into a crowdloan. Should almost certainly be at + * least `ExistentialDeposit`. + **/ + minContribution: u128 & AugmentedConst; + /** + * `PalletId` for the crowdloan pallet. An appropriate value could be `PalletId(*b"py/cfund")` + **/ + palletId: FrameSupportPalletId & AugmentedConst; + /** + * Max number of storage keys to remove per extrinsic call. + **/ + removeKeysLimit: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + democracy: { + /** + * Period in blocks where an external proposal may not be re-submitted after being vetoed. + **/ + cooloffPeriod: u32 & AugmentedConst; + /** + * The period between a proposal being approved and enacted. + * + * It should generally be a little more than the unstake period to ensure that + * voting stakers have an opportunity to remove themselves from the system in the case + * where they are on the losing side of a vote. + **/ + enactmentPeriod: u32 & AugmentedConst; + /** + * Minimum voting period allowed for a fast-track referendum. + **/ + fastTrackVotingPeriod: u32 & AugmentedConst; + /** + * Indicator for whether an emergency origin is even allowed to happen. Some chains may + * want to set this permanently to `false`, others may want to condition it on things such + * as an upgrade having happened recently. + **/ + instantAllowed: bool & AugmentedConst; + /** + * How often (in blocks) new public referenda are launched. + **/ + launchPeriod: u32 & AugmentedConst; + /** + * The maximum number of public proposals that can exist at any time. + **/ + maxProposals: u32 & AugmentedConst; + /** + * The maximum number of votes for an account. + * + * Also used to compute weight, an overly big value can + * lead to extrinsic with very big weight: see `delegate` for instance. + **/ + maxVotes: u32 & AugmentedConst; + /** + * The minimum amount to be used as a deposit for a public referendum proposal. + **/ + minimumDeposit: u128 & AugmentedConst; + /** + * The amount of balance that must be deposited per byte of preimage stored. + **/ + preimageByteDeposit: u128 & AugmentedConst; + /** + * The minimum period of vote locking. + * + * It should be no shorter than enactment period to ensure that in the case of an approval, + * those successful voters are locked into the consequences that their votes entail. + **/ + voteLockingPeriod: u32 & AugmentedConst; + /** + * How often (in blocks) to check for new votes. + **/ + votingPeriod: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + electionProviderMultiPhase: { + /** + * Maximum length (bytes) that the mined solution should consume. + * + * The miner will ensure that the total length of the unsigned solution will not exceed + * this value. + **/ + minerMaxLength: u32 & AugmentedConst; + /** + * Maximum weight that the miner should consume. + * + * The miner will ensure that the total weight of the unsigned solution will not exceed + * this value, based on [`WeightInfo::submit_unsigned`]. + **/ + minerMaxWeight: u64 & AugmentedConst; + /** + * The priority of the unsigned transaction submitted in the unsigned-phase + **/ + minerTxPriority: u64 & AugmentedConst; + /** + * The repeat threshold of the offchain worker. + * + * For example, if it is 5, that means that at least 5 blocks will elapse between attempts + * to submit the worker's solution. + **/ + offchainRepeat: u32 & AugmentedConst; + /** + * Base deposit for a signed solution. + **/ + signedDepositBase: u128 & AugmentedConst; + /** + * Per-byte deposit for a signed solution. + **/ + signedDepositByte: u128 & AugmentedConst; + /** + * Per-weight deposit for a signed solution. + **/ + signedDepositWeight: u128 & AugmentedConst; + /** + * Maximum number of signed submissions that can be queued. + * + * It is best to avoid adjusting this during an election, as it impacts downstream data + * structures. In particular, `SignedSubmissionIndices` is bounded on this value. If you + * update this value during an election, you _must_ ensure that + * `SignedSubmissionIndices.len()` is less than or equal to the new value. Otherwise, + * attempts to submit new solutions may cause a runtime panic. + **/ + signedMaxSubmissions: u32 & AugmentedConst; + /** + * Maximum weight of a signed solution. + * + * This should probably be similar to [`Config::MinerMaxWeight`]. + **/ + signedMaxWeight: u64 & AugmentedConst; + /** + * Duration of the signed phase. + **/ + signedPhase: u32 & AugmentedConst; + /** + * Base reward for a signed solution + **/ + signedRewardBase: u128 & AugmentedConst; + /** + * The minimum amount of improvement to the solution score that defines a solution as + * "better" (in any phase). + **/ + solutionImprovementThreshold: Perbill & AugmentedConst; + /** + * Duration of the unsigned phase. + **/ + unsignedPhase: u32 & AugmentedConst; + /** + * The maximum number of voters to put in the snapshot. At the moment, snapshots are only + * over a single block, but once multi-block elections are introduced they will take place + * over multiple blocks. + * + * Also, note the data type: If the voters are represented by a `u32` in `type + * CompactSolution`, the same `u32` is used here to ensure bounds are respected. + **/ + voterSnapshotPerBlock: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + grandpa: { + /** + * Max Authorities in use + **/ + maxAuthorities: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + identity: { + /** + * The amount held on deposit for a registered identity + **/ + basicDeposit: u128 & AugmentedConst; + /** + * The amount held on deposit per additional field for a registered identity. + **/ + fieldDeposit: u128 & AugmentedConst; + /** + * Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O + * required to access an identity, but can be pretty high. + **/ + maxAdditionalFields: u32 & AugmentedConst; + /** + * Maxmimum number of registrars allowed in the system. Needed to bound the complexity + * of, e.g., updating judgements. + **/ + maxRegistrars: u32 & AugmentedConst; + /** + * The maximum number of sub-accounts allowed per identified account. + **/ + maxSubAccounts: u32 & AugmentedConst; + /** + * The amount held on deposit for a registered subaccount. This should account for the fact + * that one storage item's value will increase by the size of an account ID, and there will + * be another trie item whose value is the size of an account ID plus 32 bytes. + **/ + subAccountDeposit: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + imOnline: { + /** + * A configuration for base priority of unsigned transactions. + * + * This is exposed so that it can be tuned for particular runtime, when + * multiple pallets send unsigned transactions. + **/ + unsignedPriority: u64 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + indices: { + /** + * The deposit needed for reserving an index. + **/ + deposit: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + 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: u128 & AugmentedConst; + /** + * 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: u128 & AugmentedConst; + /** + * The maximum amount of signatories allowed in the multisig. + **/ + maxSignatories: u16 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + paras: { + unsignedPriority: u64 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + phragmenElection: { + /** + * How much should be locked up in order to submit one's candidacy. + **/ + candidacyBond: u128 & AugmentedConst; + /** + * Number of members to elect. + **/ + desiredMembers: u32 & AugmentedConst; + /** + * Number of runners_up to keep. + **/ + desiredRunnersUp: u32 & AugmentedConst; + /** + * Identifier for the elections-phragmen pallet's lock + **/ + palletId: U8aFixed & AugmentedConst; + /** + * How long each seat is kept. This defines the next block number at which an election + * round will happen. If set to zero, no elections are ever triggered and the module will + * be in passive mode. + **/ + termDuration: u32 & AugmentedConst; + /** + * Base deposit associated with voting. + * + * This should be sensibly high to economically ensure the pallet cannot be attacked by + * creating a gigantic number of votes. + **/ + votingBondBase: u128 & AugmentedConst; + /** + * The amount of bond that need to be locked for each vote (32 bytes). + **/ + votingBondFactor: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + proxy: { + /** + * 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: u128 & AugmentedConst; + /** + * 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: u128 & AugmentedConst; + /** + * The maximum amount of time-delayed announcements that are allowed to be pending. + **/ + maxPending: u32 & AugmentedConst; + /** + * The maximum amount of proxies allowed for a single account. + **/ + maxProxies: u32 & AugmentedConst; + /** + * 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: u128 & AugmentedConst; + /** + * 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: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + registrar: { + /** + * The deposit to be paid per byte stored on chain. + **/ + dataDepositPerByte: u128 & AugmentedConst; + /** + * The deposit to be paid to run a parathread. + * This should include the cost for storing the genesis head and validation code. + **/ + paraDeposit: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + scheduler: { + /** + * The maximum weight that may be scheduled per block for any dispatchables of less + * priority than `schedule::HARD_DEADLINE`. + **/ + maximumWeight: u64 & AugmentedConst; + /** + * The maximum number of scheduled calls in the queue for a single block. + * Not strictly enforced, but used for weight estimation. + **/ + maxScheduledPerBlock: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + slots: { + /** + * The number of blocks to offset each lease period by. + **/ + leaseOffset: u32 & AugmentedConst; + /** + * The number of blocks over which a single period lasts. + **/ + leasePeriod: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + staking: { + /** + * Number of eras that staked funds must remain bonded for. + **/ + bondingDuration: u32 & AugmentedConst; + maxNominations: u32 & AugmentedConst; + /** + * The maximum number of nominators rewarded for each validator. + * + * For each validator only the `$MaxNominatorRewardedPerValidator` biggest stakers can + * claim their reward. This used to limit the i/o cost for the nominator payout. + **/ + maxNominatorRewardedPerValidator: u32 & AugmentedConst; + /** + * Number of sessions per era. + **/ + sessionsPerEra: u32 & AugmentedConst; + /** + * Number of eras that slashes are deferred by, after computation. + * + * This should be less than the bonding duration. Set to 0 if slashes + * should be applied immediately, without opportunity for intervention. + **/ + slashDeferDuration: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + system: { + /** + * Maximum number of block number to block hash mappings to keep (oldest pruned first). + **/ + blockHashCount: u32 & AugmentedConst; + /** + * The maximum length of a block (in bytes). + **/ + blockLength: FrameSystemLimitsBlockLength & AugmentedConst; + /** + * Block & extrinsics weights: base values and limits. + **/ + blockWeights: FrameSystemLimitsBlockWeights & AugmentedConst; + /** + * The weight of runtime database operations the runtime can invoke. + **/ + dbWeight: FrameSupportWeightsRuntimeDbWeight & AugmentedConst; + /** + * The designated SS85 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: u16 & AugmentedConst; + /** + * Get the chain's current version. + **/ + version: SpVersionRuntimeVersion & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + timestamp: { + /** + * The minimum period between blocks. Beware that this is different to the *expected* + * period that the block production apparatus provides. Your chosen consensus system will + * generally work with this to determine a sensible block time. e.g. For Aura, it will be + * double this period on default settings. + **/ + minimumPeriod: u64 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + tips: { + /** + * The amount held on deposit per byte within the tip report reason or bounty description. + **/ + dataDepositPerByte: u128 & AugmentedConst; + /** + * Maximum acceptable reason length. + * + * Benchmarks depend on this value, be sure to update weights file when changing this value + **/ + maximumReasonLength: u32 & AugmentedConst; + /** + * The period for which a tip remains open after is has achieved threshold tippers. + **/ + tipCountdown: u32 & AugmentedConst; + /** + * The percent of the final tip which goes to the original reporter of the tip. + **/ + tipFindersFee: Percent & AugmentedConst; + /** + * The amount held on deposit for placing a tip report. + **/ + tipReportDepositBase: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + transactionPayment: { + /** + * A fee mulitplier for `Operational` extrinsics to compute "virtual tip" to boost their + * `priority` + * + * This value is multipled by the `final_fee` to obtain a "virtual tip" that is later + * added to a tip component in regular `priority` calculations. + * It means that a `Normal` transaction can front-run a similarly-sized `Operational` + * extrinsic (with no tip), by including a tip value greater than the virtual tip. + * + * ```rust,ignore + * // For `Normal` + * let priority = priority_calc(tip); + * + * // For `Operational` + * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier; + * let priority = priority_calc(tip + virtual_tip); + * ``` + * + * Note that since we use `final_fee` the multiplier applies also to the regular `tip` + * sent with the transaction. So, not only does the transaction get a priority bump based + * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational` + * transactions. + **/ + operationalFeeMultiplier: u8 & AugmentedConst; + /** + * The fee to be paid for making a transaction; the per-byte portion. + **/ + transactionByteFee: u128 & AugmentedConst; + /** + * The polynomial that is applied in order to derive fee from weight. + **/ + weightToFee: Vec & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + treasury: { + /** + * Percentage of spare funds (if any) that are burnt per spend period. + **/ + burn: Permill & AugmentedConst; + /** + * The maximum number of approvals that can wait in the spending queue. + **/ + maxApprovals: u32 & AugmentedConst; + /** + * The treasury's pallet id, used for deriving its sovereign account ID. + **/ + palletId: FrameSupportPalletId & AugmentedConst; + /** + * Fraction of a proposal's value that should be bonded in order to place the proposal. + * An accepted proposal gets these back. A rejected proposal does not. + **/ + proposalBond: Permill & AugmentedConst; + /** + * Minimum amount of funds that should be placed in a deposit for making a proposal. + **/ + proposalBondMinimum: u128 & AugmentedConst; + /** + * Period between successive spends. + **/ + spendPeriod: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + utility: { + /** + * The limit on the number of batched calls. + **/ + batchedCallsLimit: u32 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + vesting: { + maxVestingSchedules: u32 & AugmentedConst; + /** + * The minimum amount transferred to call `vested_transfer`. + **/ + minVestedTransfer: u128 & AugmentedConst; + /** + * Generic const + **/ + [key: string]: Codec; + }; + } // AugmentedConsts +} // declare module diff --git a/packages/api-augment/src/polkadot/errors.ts b/packages/api-augment/src/polkadot/errors.ts new file mode 100644 index 0000000000..1e963129cf --- /dev/null +++ b/packages/api-augment/src/polkadot/errors.ts @@ -0,0 +1,1638 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; + +declare module '@polkadot/api-base/types/errors' { + export interface AugmentedErrors { + auctions: { + /** + * The para is already leased out for part of this range. + **/ + AlreadyLeasedOut: AugmentedError; + /** + * Auction has already ended. + **/ + AuctionEnded: AugmentedError; + /** + * This auction is already in progress. + **/ + AuctionInProgress: AugmentedError; + /** + * The lease period is in the past. + **/ + LeasePeriodInPast: AugmentedError; + /** + * Not an auction. + **/ + NotAuction: AugmentedError; + /** + * Not a current auction. + **/ + NotCurrentAuction: AugmentedError; + /** + * Para is not registered + **/ + ParaNotRegistered: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + authorship: { + /** + * The uncle is genesis. + **/ + GenesisUncle: AugmentedError; + /** + * The uncle parent not in the chain. + **/ + InvalidUncleParent: AugmentedError; + /** + * The uncle isn't recent enough to be included. + **/ + OldUncle: AugmentedError; + /** + * The uncle is too high in chain. + **/ + TooHighUncle: AugmentedError; + /** + * Too many uncles. + **/ + TooManyUncles: AugmentedError; + /** + * The uncle is already included. + **/ + UncleAlreadyIncluded: AugmentedError; + /** + * Uncles already set in the block. + **/ + UnclesAlreadySet: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + babe: { + /** + * A given equivocation report is valid but already previously reported. + **/ + DuplicateOffenceReport: AugmentedError; + /** + * An equivocation proof provided as part of an equivocation report is invalid. + **/ + InvalidEquivocationProof: AugmentedError; + /** + * A key ownership proof provided as part of an equivocation report is invalid. + **/ + InvalidKeyOwnershipProof: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + bagsList: { + /** + * Id not found in list. + **/ + IdNotFound: AugmentedError; + /** + * An Id does not have a greater vote weight than another Id. + **/ + NotHeavier: AugmentedError; + /** + * Attempted to place node in front of a node in another bag. + **/ + NotInSameBag: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + balances: { + /** + * Beneficiary account must pre-exist + **/ + DeadAccount: AugmentedError; + /** + * Value too low to create account due to existential deposit + **/ + ExistentialDeposit: AugmentedError; + /** + * A vesting schedule already exists for this account + **/ + ExistingVestingSchedule: AugmentedError; + /** + * Balance too low to send value + **/ + InsufficientBalance: AugmentedError; + /** + * Transfer/payment would kill account + **/ + KeepAlive: AugmentedError; + /** + * Account liquidity restrictions prevent withdrawal + **/ + LiquidityRestrictions: AugmentedError; + /** + * Number of named reserves exceed MaxReserves + **/ + TooManyReserves: AugmentedError; + /** + * Vesting balance too high to send value + **/ + VestingBalance: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + bounties: { + /** + * The bounty cannot be closed because it has active child-bounties. + **/ + HasActiveChildBounty: AugmentedError; + /** + * Proposer's balance is too low. + **/ + InsufficientProposersBalance: AugmentedError; + /** + * Invalid bounty fee. + **/ + InvalidFee: AugmentedError; + /** + * No proposal or bounty at that index. + **/ + InvalidIndex: AugmentedError; + /** + * Invalid bounty value. + **/ + InvalidValue: AugmentedError; + /** + * A bounty payout is pending. + * To cancel the bounty, you must unassign and slash the curator. + **/ + PendingPayout: AugmentedError; + /** + * The bounties cannot be claimed/closed because it's still in the countdown period. + **/ + Premature: AugmentedError; + /** + * The reason given is just too big. + **/ + ReasonTooBig: AugmentedError; + /** + * Require bounty curator. + **/ + RequireCurator: AugmentedError; + /** + * The bounty status is unexpected. + **/ + UnexpectedStatus: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + claims: { + /** + * Invalid Ethereum signature. + **/ + InvalidEthereumSignature: AugmentedError; + /** + * A needed statement was not included. + **/ + InvalidStatement: AugmentedError; + /** + * There's not enough in the pot to pay out some unvested amount. Generally implies a logic + * error. + **/ + PotUnderflow: AugmentedError; + /** + * Account ID sending transaction has no claim. + **/ + SenderHasNoClaim: AugmentedError; + /** + * Ethereum address has no claim. + **/ + SignerHasNoClaim: AugmentedError; + /** + * The account already has a vested balance. + **/ + VestedBalanceExists: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + configuration: { + /** + * The new value for a configuration parameter is invalid. + **/ + InvalidNewValue: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + council: { + /** + * Members are already initialized! + **/ + AlreadyInitialized: AugmentedError; + /** + * Duplicate proposals not allowed + **/ + DuplicateProposal: AugmentedError; + /** + * Duplicate vote ignored + **/ + DuplicateVote: AugmentedError; + /** + * Account is not a member + **/ + NotMember: AugmentedError; + /** + * Proposal must exist + **/ + ProposalMissing: AugmentedError; + /** + * The close call was made too early, before the end of the voting. + **/ + TooEarly: AugmentedError; + /** + * There can only be a maximum of `MaxProposals` active proposals. + **/ + TooManyProposals: AugmentedError; + /** + * Mismatched index + **/ + WrongIndex: AugmentedError; + /** + * The given length bound for the proposal was too low. + **/ + WrongProposalLength: AugmentedError; + /** + * The given weight bound for the proposal was too low. + **/ + WrongProposalWeight: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + crowdloan: { + /** + * The fund is already in `NewRaise` + **/ + AlreadyInNewRaise: AugmentedError; + /** + * This parachain's bid or lease is still active and withdraw cannot yet begin. + **/ + BidOrLeaseActive: AugmentedError; + /** + * The campaign ends before the current block number. The end must be in the future. + **/ + CannotEndInPast: AugmentedError; + /** + * Contributions exceed maximum amount. + **/ + CapExceeded: AugmentedError; + /** + * The contribution period has already ended. + **/ + ContributionPeriodOver: AugmentedError; + /** + * The contribution was below the minimum, `MinContribution`. + **/ + ContributionTooSmall: AugmentedError; + /** + * The end date for this crowdloan is not sensible. + **/ + EndTooFarInFuture: AugmentedError; + /** + * The current lease period is more than the first lease period. + **/ + FirstPeriodInPast: AugmentedError; + /** + * The first lease period needs to at least be less than 3 `max_value`. + **/ + FirstPeriodTooFarInFuture: AugmentedError; + /** + * The crowdloan has not yet ended. + **/ + FundNotEnded: AugmentedError; + /** + * The origin of this call is invalid. + **/ + InvalidOrigin: AugmentedError; + /** + * Invalid fund index. + **/ + InvalidParaId: AugmentedError; + /** + * Invalid signature. + **/ + InvalidSignature: AugmentedError; + /** + * Last lease period must be greater than first lease period. + **/ + LastPeriodBeforeFirstPeriod: AugmentedError; + /** + * The last lease period cannot be more than 3 periods after the first period. + **/ + LastPeriodTooFarInFuture: AugmentedError; + /** + * This parachain lease is still active and retirement cannot yet begin. + **/ + LeaseActive: AugmentedError; + /** + * The provided memo is too large. + **/ + MemoTooLarge: AugmentedError; + /** + * There are no contributions stored in this crowdloan. + **/ + NoContributions: AugmentedError; + /** + * A lease period has not started yet, due to an offset in the starting block. + **/ + NoLeasePeriod: AugmentedError; + /** + * This crowdloan does not correspond to a parachain. + **/ + NotParachain: AugmentedError; + /** + * The crowdloan is not ready to dissolve. Potentially still has a slot or in retirement period. + **/ + NotReadyToDissolve: AugmentedError; + /** + * There was an overflow. + **/ + Overflow: AugmentedError; + /** + * No contributions allowed during the VRF delay + **/ + VrfDelayInProgress: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + democracy: { + /** + * Cannot cancel the same proposal twice + **/ + AlreadyCanceled: AugmentedError; + /** + * The account is already delegating. + **/ + AlreadyDelegating: AugmentedError; + /** + * Identity may not veto a proposal twice + **/ + AlreadyVetoed: AugmentedError; + /** + * Preimage already noted + **/ + DuplicatePreimage: AugmentedError; + /** + * Proposal already made + **/ + DuplicateProposal: AugmentedError; + /** + * Imminent + **/ + Imminent: AugmentedError; + /** + * The instant referendum origin is currently disallowed. + **/ + InstantNotAllowed: AugmentedError; + /** + * Too high a balance was provided that the account cannot afford. + **/ + InsufficientFunds: AugmentedError; + /** + * Invalid hash + **/ + InvalidHash: AugmentedError; + /** + * Maximum number of votes reached. + **/ + MaxVotesReached: AugmentedError; + /** + * No proposals waiting + **/ + NoneWaiting: AugmentedError; + /** + * Delegation to oneself makes no sense. + **/ + Nonsense: AugmentedError; + /** + * The actor has no permission to conduct the action. + **/ + NoPermission: AugmentedError; + /** + * No external proposal + **/ + NoProposal: AugmentedError; + /** + * The account is not currently delegating. + **/ + NotDelegating: AugmentedError; + /** + * Not imminent + **/ + NotImminent: AugmentedError; + /** + * Next external proposal not simple majority + **/ + NotSimpleMajority: AugmentedError; + /** + * The given account did not vote on the referendum. + **/ + NotVoter: AugmentedError; + /** + * Invalid preimage + **/ + PreimageInvalid: AugmentedError; + /** + * Preimage not found + **/ + PreimageMissing: AugmentedError; + /** + * Proposal still blacklisted + **/ + ProposalBlacklisted: AugmentedError; + /** + * Proposal does not exist + **/ + ProposalMissing: AugmentedError; + /** + * Vote given for invalid referendum + **/ + ReferendumInvalid: AugmentedError; + /** + * Too early + **/ + TooEarly: AugmentedError; + /** + * Maximum number of proposals reached. + **/ + TooManyProposals: AugmentedError; + /** + * Value too low + **/ + ValueLow: AugmentedError; + /** + * The account currently has votes attached to it and the operation cannot succeed until + * these are removed, either through `unvote` or `reap_vote`. + **/ + VotesExist: AugmentedError; + /** + * Invalid upper bound. + **/ + WrongUpperBound: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + electionProviderMultiPhase: { + /** + * The call is not allowed at this point. + **/ + CallNotAllowed: AugmentedError; + /** + * `Self::insert_submission` returned an invalid index. + **/ + InvalidSubmissionIndex: AugmentedError; + /** + * Snapshot metadata should exist but didn't. + **/ + MissingSnapshotMetadata: AugmentedError; + /** + * OCW submitted solution for wrong round + **/ + OcwCallWrongEra: AugmentedError; + /** + * Submission was too early. + **/ + PreDispatchEarlySubmission: AugmentedError; + /** + * Submission was too weak, score-wise. + **/ + PreDispatchWeakSubmission: AugmentedError; + /** + * Wrong number of winners presented. + **/ + PreDispatchWrongWinnerCount: AugmentedError; + /** + * The origin failed to pay the deposit. + **/ + SignedCannotPayDeposit: AugmentedError; + /** + * Witness data to dispatchable is invalid. + **/ + SignedInvalidWitness: AugmentedError; + /** + * The queue was full, and the solution was not better than any of the existing ones. + **/ + SignedQueueFull: AugmentedError; + /** + * The signed submission consumes too much weight + **/ + SignedTooMuchWeight: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + grandpa: { + /** + * Attempt to signal GRANDPA change with one already pending. + **/ + ChangePending: AugmentedError; + /** + * A given equivocation report is valid but already previously reported. + **/ + DuplicateOffenceReport: AugmentedError; + /** + * An equivocation proof provided as part of an equivocation report is invalid. + **/ + InvalidEquivocationProof: AugmentedError; + /** + * A key ownership proof provided as part of an equivocation report is invalid. + **/ + InvalidKeyOwnershipProof: AugmentedError; + /** + * Attempt to signal GRANDPA pause when the authority set isn't live + * (either paused or already pending pause). + **/ + PauseFailed: AugmentedError; + /** + * Attempt to signal GRANDPA resume when the authority set isn't paused + * (either live or already pending resume). + **/ + ResumeFailed: AugmentedError; + /** + * Cannot signal forced change so soon after last. + **/ + TooSoon: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + hrmp: { + /** + * The channel is already confirmed. + **/ + AcceptHrmpChannelAlreadyConfirmed: AugmentedError; + /** + * The channel from the sender to the origin doesn't exist. + **/ + AcceptHrmpChannelDoesntExist: AugmentedError; + /** + * The recipient already has the maximum number of allowed inbound channels. + **/ + AcceptHrmpChannelLimitExceeded: AugmentedError; + /** + * Canceling is requested by neither the sender nor recipient of the open channel request. + **/ + CancelHrmpOpenChannelUnauthorized: AugmentedError; + /** + * The channel close request is already requested. + **/ + CloseHrmpChannelAlreadyUnderway: AugmentedError; + /** + * The channel to be closed doesn't exist. + **/ + CloseHrmpChannelDoesntExist: AugmentedError; + /** + * The origin tries to close a channel where it is neither the sender nor the recipient. + **/ + CloseHrmpChannelUnauthorized: AugmentedError; + /** + * Cannot cancel an HRMP open channel request because it is already confirmed. + **/ + OpenHrmpChannelAlreadyConfirmed: AugmentedError; + /** + * The channel already exists + **/ + OpenHrmpChannelAlreadyExists: AugmentedError; + /** + * There is already a request to open the same channel. + **/ + OpenHrmpChannelAlreadyRequested: AugmentedError; + /** + * The requested capacity exceeds the global limit. + **/ + OpenHrmpChannelCapacityExceedsLimit: AugmentedError; + /** + * The open request doesn't exist. + **/ + OpenHrmpChannelDoesntExist: AugmentedError; + /** + * The recipient is not a valid para. + **/ + OpenHrmpChannelInvalidRecipient: AugmentedError; + /** + * The sender already has the maximum number of allowed outbound channels. + **/ + OpenHrmpChannelLimitExceeded: AugmentedError; + /** + * The open request requested the message size that exceeds the global limit. + **/ + OpenHrmpChannelMessageSizeExceedsLimit: AugmentedError; + /** + * The sender tried to open a channel to themselves. + **/ + OpenHrmpChannelToSelf: AugmentedError; + /** + * The requested capacity is zero. + **/ + OpenHrmpChannelZeroCapacity: AugmentedError; + /** + * The requested maximum message size is 0. + **/ + OpenHrmpChannelZeroMessageSize: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + identity: { + /** + * Account ID is already named. + **/ + AlreadyClaimed: AugmentedError; + /** + * Empty index. + **/ + EmptyIndex: AugmentedError; + /** + * Fee is changed. + **/ + FeeChanged: AugmentedError; + /** + * The index is invalid. + **/ + InvalidIndex: AugmentedError; + /** + * Invalid judgement. + **/ + InvalidJudgement: AugmentedError; + /** + * The target is invalid. + **/ + InvalidTarget: AugmentedError; + /** + * Judgement given. + **/ + JudgementGiven: AugmentedError; + /** + * No identity found. + **/ + NoIdentity: AugmentedError; + /** + * Account isn't found. + **/ + NotFound: AugmentedError; + /** + * Account isn't named. + **/ + NotNamed: AugmentedError; + /** + * Sub-account isn't owned by sender. + **/ + NotOwned: AugmentedError; + /** + * Sender is not a sub-account. + **/ + NotSub: AugmentedError; + /** + * Sticky judgement. + **/ + StickyJudgement: AugmentedError; + /** + * Too many additional fields. + **/ + TooManyFields: AugmentedError; + /** + * Maximum amount of registrars reached. Cannot add any more. + **/ + TooManyRegistrars: AugmentedError; + /** + * Too many subs-accounts. + **/ + TooManySubAccounts: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + imOnline: { + /** + * Duplicated heartbeat. + **/ + DuplicatedHeartbeat: AugmentedError; + /** + * Non existent public key. + **/ + InvalidKey: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + indices: { + /** + * The index was not available. + **/ + InUse: AugmentedError; + /** + * The index was not already assigned. + **/ + NotAssigned: AugmentedError; + /** + * The index is assigned to another account. + **/ + NotOwner: AugmentedError; + /** + * The source and destination accounts are identical. + **/ + NotTransfer: AugmentedError; + /** + * The index is permanent and may not be freed/changed. + **/ + Permanent: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + multisig: { + /** + * Call is already approved by this signatory. + **/ + AlreadyApproved: AugmentedError; + /** + * The data to be stored is already stored. + **/ + AlreadyStored: AugmentedError; + /** + * The maximum weight information provided was too low. + **/ + MaxWeightTooLow: AugmentedError; + /** + * Threshold must be 2 or greater. + **/ + MinimumThreshold: AugmentedError; + /** + * Call doesn't need any (more) approvals. + **/ + NoApprovalsNeeded: AugmentedError; + /** + * Multisig operation not found when attempting to cancel. + **/ + NotFound: AugmentedError; + /** + * No timepoint was given, yet the multisig operation is already underway. + **/ + NoTimepoint: AugmentedError; + /** + * Only the account that originally created the multisig is able to cancel it. + **/ + NotOwner: AugmentedError; + /** + * The sender was contained in the other signatories; it shouldn't be. + **/ + SenderInSignatories: AugmentedError; + /** + * The signatories were provided out of order; they should be ordered. + **/ + SignatoriesOutOfOrder: AugmentedError; + /** + * There are too few signatories in the list. + **/ + TooFewSignatories: AugmentedError; + /** + * There are too many signatories in the list. + **/ + TooManySignatories: AugmentedError; + /** + * A timepoint was given, yet no multisig operation is underway. + **/ + UnexpectedTimepoint: AugmentedError; + /** + * A different timepoint was given to the multisig operation that is underway. + **/ + WrongTimepoint: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + paraInclusion: { + /** + * Multiple bitfields submitted by same validator or validators out of order by index. + **/ + BitfieldDuplicateOrUnordered: AugmentedError; + /** + * A bitfield that references a freed core, + * either intentionally or as part of a concluded + * invalid dispute. + **/ + BitfieldReferencesFreedCore: AugmentedError; + /** + * Candidate not in parent context. + **/ + CandidateNotInParentContext: AugmentedError; + /** + * Candidate scheduled despite pending candidate already existing for the para. + **/ + CandidateScheduledBeforeParaFree: AugmentedError; + /** + * Head data exceeds the configured maximum. + **/ + HeadDataTooLarge: AugmentedError; + /** + * The candidate didn't follow the rules of HRMP watermark advancement. + **/ + HrmpWatermarkMishandling: AugmentedError; + /** + * The downward message queue is not processed correctly. + **/ + IncorrectDownwardMessageHandling: AugmentedError; + /** + * Insufficient (non-majority) backing. + **/ + InsufficientBacking: AugmentedError; + /** + * Invalid (bad signature, unknown validator, etc.) backing. + **/ + InvalidBacking: AugmentedError; + /** + * Invalid signature + **/ + InvalidBitfieldSignature: AugmentedError; + /** + * Invalid group index in core assignment. + **/ + InvalidGroupIndex: AugmentedError; + /** + * The HRMP messages sent by the candidate is not valid. + **/ + InvalidOutboundHrmp: AugmentedError; + /** + * At least one upward message sent does not pass the acceptance criteria. + **/ + InvalidUpwardMessages: AugmentedError; + /** + * The validation code hash of the candidate is not valid. + **/ + InvalidValidationCodeHash: AugmentedError; + /** + * Output code is too large + **/ + NewCodeTooLarge: AugmentedError; + /** + * Collator did not sign PoV. + **/ + NotCollatorSigned: AugmentedError; + /** + * The `para_head` hash in the candidate descriptor doesn't match the hash of the actual para head in the + * commitments. + **/ + ParaHeadMismatch: AugmentedError; + /** + * Code upgrade prematurely. + **/ + PrematureCodeUpgrade: AugmentedError; + /** + * Scheduled cores out of order. + **/ + ScheduledOutOfOrder: AugmentedError; + /** + * Candidate submitted but para not scheduled. + **/ + UnscheduledCandidate: AugmentedError; + /** + * The validation data hash does not match expected. + **/ + ValidationDataHashMismatch: AugmentedError; + /** + * Validator index out of bounds. + **/ + ValidatorIndexOutOfBounds: AugmentedError; + /** + * Availability bitfield has unexpected size. + **/ + WrongBitfieldSize: AugmentedError; + /** + * Candidate included with the wrong collator. + **/ + WrongCollator: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + paraInherent: { + /** + * Disputed candidate that was concluded invalid. + **/ + CandidateConcludedInvalid: AugmentedError; + /** + * The data given to the inherent will result in an overweight block. + **/ + InherentOverweight: AugmentedError; + /** + * The hash of the submitted parent header doesn't correspond to the saved block hash of + * the parent. + **/ + InvalidParentHeader: AugmentedError; + /** + * Inclusion inherent called more than once per block. + **/ + TooManyInclusionInherents: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + paras: { + /** + * Para cannot be downgraded to a parathread. + **/ + CannotDowngrade: AugmentedError; + /** + * Para cannot be offboarded at this time. + **/ + CannotOffboard: AugmentedError; + /** + * Para cannot be onboarded because it is already tracked by our system. + **/ + CannotOnboard: AugmentedError; + /** + * Para cannot be upgraded to a parachain. + **/ + CannotUpgrade: AugmentedError; + /** + * Para is not registered in our system. + **/ + NotRegistered: AugmentedError; + /** + * The given validator already has cast a vote. + **/ + PvfCheckDoubleVote: AugmentedError; + /** + * The signature for the PVF pre-checking is invalid. + **/ + PvfCheckInvalidSignature: AugmentedError; + /** + * The statement for PVF pre-checking is for a future session. + **/ + PvfCheckStatementFuture: AugmentedError; + /** + * The statement for PVF pre-checking is stale. + **/ + PvfCheckStatementStale: AugmentedError; + /** + * The given PVF does not exist at the moment of process a vote. + **/ + PvfCheckSubjectInvalid: AugmentedError; + /** + * Claimed validator index is out of bounds. + **/ + PvfCheckValidatorIndexOutOfBounds: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + phragmenElection: { + /** + * Duplicated candidate submission. + **/ + DuplicatedCandidate: AugmentedError; + /** + * Candidate does not have enough funds. + **/ + InsufficientCandidateFunds: AugmentedError; + /** + * The renouncing origin presented a wrong `Renouncing` parameter. + **/ + InvalidRenouncing: AugmentedError; + /** + * Prediction regarding replacement after member removal is wrong. + **/ + InvalidReplacement: AugmentedError; + /** + * The provided count of number of votes is incorrect. + **/ + InvalidVoteCount: AugmentedError; + /** + * The provided count of number of candidates is incorrect. + **/ + InvalidWitnessData: AugmentedError; + /** + * Cannot vote with stake less than minimum balance. + **/ + LowBalance: AugmentedError; + /** + * Cannot vote more than maximum allowed. + **/ + MaximumVotesExceeded: AugmentedError; + /** + * Member cannot re-submit candidacy. + **/ + MemberSubmit: AugmentedError; + /** + * Must be a voter. + **/ + MustBeVoter: AugmentedError; + /** + * Not a member. + **/ + NotMember: AugmentedError; + /** + * Must vote for at least one candidate. + **/ + NoVotes: AugmentedError; + /** + * Cannot report self. + **/ + ReportSelf: AugmentedError; + /** + * Runner cannot re-submit candidacy. + **/ + RunnerUpSubmit: AugmentedError; + /** + * Cannot vote more than candidates. + **/ + TooManyVotes: AugmentedError; + /** + * Voter can not pay voting bond. + **/ + UnableToPayBond: AugmentedError; + /** + * Cannot vote when no candidates or members exist. + **/ + UnableToVote: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + preimage: { + /** + * Preimage has already been noted on-chain. + **/ + AlreadyNoted: AugmentedError; + /** + * The user is not authorized to perform this action. + **/ + NotAuthorized: AugmentedError; + /** + * The preimage cannot be removed since it has not yet been noted. + **/ + NotNoted: AugmentedError; + /** + * The preimage request cannot be removed since no outstanding requests exist. + **/ + NotRequested: AugmentedError; + /** + * A preimage may not be removed when there are outstanding requests. + **/ + Requested: AugmentedError; + /** + * Preimage is too large to store on-chain. + **/ + TooLarge: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + proxy: { + /** + * Account is already a proxy. + **/ + Duplicate: AugmentedError; + /** + * Call may not be made by proxy because it may escalate its privileges. + **/ + NoPermission: AugmentedError; + /** + * Cannot add self as proxy. + **/ + NoSelfProxy: AugmentedError; + /** + * Proxy registration not found. + **/ + NotFound: AugmentedError; + /** + * Sender is not a proxy of the account to be proxied. + **/ + NotProxy: AugmentedError; + /** + * There are too many proxies registered or too many announcements pending. + **/ + TooMany: AugmentedError; + /** + * Announcement, if made at all, was made too recently. + **/ + Unannounced: AugmentedError; + /** + * A call which is incompatible with the proxy type's filter was attempted. + **/ + Unproxyable: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + registrar: { + /** + * The ID is already registered. + **/ + AlreadyRegistered: AugmentedError; + /** + * Cannot deregister para + **/ + CannotDeregister: AugmentedError; + /** + * Cannot schedule downgrade of parachain to parathread + **/ + CannotDowngrade: AugmentedError; + /** + * Cannot schedule upgrade of parathread to parachain + **/ + CannotUpgrade: AugmentedError; + /** + * Invalid para code size. + **/ + CodeTooLarge: AugmentedError; + /** + * Registering parachain with empty code is not allowed. + **/ + EmptyCode: AugmentedError; + /** + * Invalid para head data size. + **/ + HeadDataTooLarge: AugmentedError; + /** + * The caller is not the owner of this Id. + **/ + NotOwner: AugmentedError; + /** + * Para is not a Parachain. + **/ + NotParachain: AugmentedError; + /** + * Para is not a Parathread. + **/ + NotParathread: AugmentedError; + /** + * The ID is not registered. + **/ + NotRegistered: AugmentedError; + /** + * The ID given for registration has not been reserved. + **/ + NotReserved: AugmentedError; + /** + * Para is locked from manipulation by the manager. Must use parachain or relay chain governance. + **/ + ParaLocked: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + scheduler: { + /** + * Failed to schedule a call + **/ + FailedToSchedule: AugmentedError; + /** + * Cannot find the scheduled call. + **/ + NotFound: AugmentedError; + /** + * Reschedule failed because it does not change scheduled time. + **/ + RescheduleNoChange: AugmentedError; + /** + * Given target block number is in the past. + **/ + TargetBlockNumberInPast: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + session: { + /** + * Registered duplicate key. + **/ + DuplicatedKey: AugmentedError; + /** + * Invalid ownership proof. + **/ + InvalidProof: AugmentedError; + /** + * Key setting account is not live, so it's impossible to associate keys. + **/ + NoAccount: AugmentedError; + /** + * No associated validator ID for account. + **/ + NoAssociatedValidatorId: AugmentedError; + /** + * No keys are associated with this account. + **/ + NoKeys: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + slots: { + /** + * There was an error with the lease. + **/ + LeaseError: AugmentedError; + /** + * The parachain ID is not onboarding. + **/ + ParaNotOnboarding: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + staking: { + /** + * Stash is already bonded. + **/ + AlreadyBonded: AugmentedError; + /** + * Rewards for this era have already been claimed for this validator. + **/ + AlreadyClaimed: AugmentedError; + /** + * Controller is already paired. + **/ + AlreadyPaired: AugmentedError; + /** + * Internal state has become somehow corrupted and the operation cannot continue. + **/ + BadState: AugmentedError; + /** + * A nomination target was supplied that was blocked or otherwise not a validator. + **/ + BadTarget: AugmentedError; + /** + * The user has enough bond and thus cannot be chilled forcefully by an external person. + **/ + CannotChillOther: AugmentedError; + /** + * Commission is too low. Must be at least `MinCommission`. + **/ + CommissionTooLow: AugmentedError; + /** + * Duplicate index. + **/ + DuplicateIndex: AugmentedError; + /** + * Targets cannot be empty. + **/ + EmptyTargets: AugmentedError; + /** + * Attempting to target a stash that still has funds. + **/ + FundedTarget: AugmentedError; + /** + * Incorrect previous history depth input provided. + **/ + IncorrectHistoryDepth: AugmentedError; + /** + * Incorrect number of slashing spans provided. + **/ + IncorrectSlashingSpans: AugmentedError; + /** + * Cannot have a validator or nominator role, with value less than the minimum defined by + * governance (see `MinValidatorBond` and `MinNominatorBond`). If unbonding is the + * intention, `chill` first to remove one's role as validator/nominator. + **/ + InsufficientBond: AugmentedError; + /** + * Invalid era to reward. + **/ + InvalidEraToReward: AugmentedError; + /** + * Invalid number of nominations. + **/ + InvalidNumberOfNominations: AugmentedError; + /** + * Slash record index out of bounds. + **/ + InvalidSlashIndex: AugmentedError; + /** + * Can not schedule more unlock chunks. + **/ + NoMoreChunks: AugmentedError; + /** + * Not a controller account. + **/ + NotController: AugmentedError; + /** + * Items are not sorted and unique. + **/ + NotSortedAndUnique: AugmentedError; + /** + * Not a stash account. + **/ + NotStash: AugmentedError; + /** + * Can not rebond without unlocking chunks. + **/ + NoUnlockChunk: AugmentedError; + /** + * There are too many nominators in the system. Governance needs to adjust the staking + * settings to keep things safe for the runtime. + **/ + TooManyNominators: AugmentedError; + /** + * Too many nomination targets supplied. + **/ + TooManyTargets: AugmentedError; + /** + * There are too many validators in the system. Governance needs to adjust the staking + * settings to keep things safe for the runtime. + **/ + TooManyValidators: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + system: { + /** + * The origin filter prevent the call to be dispatched. + **/ + CallFiltered: AugmentedError; + /** + * Failed to extract the runtime version from the new runtime. + * + * Either calling `Core_version` or decoding `RuntimeVersion` failed. + **/ + FailedToExtractRuntimeVersion: AugmentedError; + /** + * The name of specification does not match between the current runtime + * and the new runtime. + **/ + InvalidSpecName: AugmentedError; + /** + * Suicide called when the account has non-default composite data. + **/ + NonDefaultComposite: AugmentedError; + /** + * There is a non-zero reference count preventing the account from being purged. + **/ + NonZeroRefCount: AugmentedError; + /** + * The specification version is not allowed to decrease between the current runtime + * and the new runtime. + **/ + SpecVersionNeedsToIncrease: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + technicalCommittee: { + /** + * Members are already initialized! + **/ + AlreadyInitialized: AugmentedError; + /** + * Duplicate proposals not allowed + **/ + DuplicateProposal: AugmentedError; + /** + * Duplicate vote ignored + **/ + DuplicateVote: AugmentedError; + /** + * Account is not a member + **/ + NotMember: AugmentedError; + /** + * Proposal must exist + **/ + ProposalMissing: AugmentedError; + /** + * The close call was made too early, before the end of the voting. + **/ + TooEarly: AugmentedError; + /** + * There can only be a maximum of `MaxProposals` active proposals. + **/ + TooManyProposals: AugmentedError; + /** + * Mismatched index + **/ + WrongIndex: AugmentedError; + /** + * The given length bound for the proposal was too low. + **/ + WrongProposalLength: AugmentedError; + /** + * The given weight bound for the proposal was too low. + **/ + WrongProposalWeight: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + technicalMembership: { + /** + * Already a member. + **/ + AlreadyMember: AugmentedError; + /** + * Not a member. + **/ + NotMember: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + tips: { + /** + * The tip was already found/started. + **/ + AlreadyKnown: AugmentedError; + /** + * The account attempting to retract the tip is not the finder of the tip. + **/ + NotFinder: AugmentedError; + /** + * The tip cannot be claimed/closed because it's still in the countdown period. + **/ + Premature: AugmentedError; + /** + * The reason given is just too big. + **/ + ReasonTooBig: AugmentedError; + /** + * The tip cannot be claimed/closed because there are not enough tippers yet. + **/ + StillOpen: AugmentedError; + /** + * The tip hash is unknown. + **/ + UnknownTip: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + treasury: { + /** + * Proposer's balance is too low. + **/ + InsufficientProposersBalance: AugmentedError; + /** + * No proposal or bounty at that index. + **/ + InvalidIndex: AugmentedError; + /** + * Too many approvals in the queue. + **/ + TooManyApprovals: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + ump: { + /** + * The message index given is unknown. + **/ + UnknownMessageIndex: AugmentedError; + /** + * The amount of weight given is possibly not enough for executing the message. + **/ + WeightOverLimit: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + utility: { + /** + * Too many calls batched. + **/ + TooManyCalls: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + vesting: { + /** + * Amount being transferred is too low to create a vesting schedule. + **/ + AmountLow: AugmentedError; + /** + * The account already has `MaxVestingSchedules` count of schedules and thus + * cannot add another one. Consider merging existing schedules in order to add another. + **/ + AtMaxVestingSchedules: AugmentedError; + /** + * Failed to create a new schedule because some parameter was invalid. + **/ + InvalidScheduleParams: AugmentedError; + /** + * The account given is not vesting. + **/ + NotVesting: AugmentedError; + /** + * An index was out of bounds of the vesting schedules. + **/ + ScheduleIndexOutOfBounds: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + xcmPallet: { + /** + * The location is invalid since it already has a subscription from us. + **/ + AlreadySubscribed: AugmentedError; + /** + * The given location could not be used (e.g. because it cannot be expressed in the + * desired version of XCM). + **/ + BadLocation: AugmentedError; + /** + * The version of the `Versioned` value used is not able to be interpreted. + **/ + BadVersion: AugmentedError; + /** + * Could not re-anchor the assets to declare the fees for the destination chain. + **/ + CannotReanchor: AugmentedError; + /** + * The destination `MultiLocation` provided cannot be inverted. + **/ + DestinationNotInvertible: AugmentedError; + /** + * The assets to be sent are empty. + **/ + Empty: AugmentedError; + /** + * The message execution fails the filter. + **/ + Filtered: AugmentedError; + /** + * Origin is invalid for sending. + **/ + InvalidOrigin: AugmentedError; + /** + * The referenced subscription could not be found. + **/ + NoSubscription: AugmentedError; + /** + * 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: AugmentedError; + /** + * Too many assets have been attempted for transfer. + **/ + TooManyAssets: AugmentedError; + /** + * The desired destination was unreachable, generally because there is a no way of routing + * to it. + **/ + Unreachable: AugmentedError; + /** + * The message's weight could not be determined. + **/ + UnweighableMessage: AugmentedError; + /** + * Generic error + **/ + [key: string]: AugmentedError; + }; + } // AugmentedErrors +} // declare module diff --git a/packages/api-augment/src/polkadot/events.ts b/packages/api-augment/src/polkadot/events.ts new file mode 100644 index 0000000000..25636b6072 --- /dev/null +++ b/packages/api-augment/src/polkadot/events.ts @@ -0,0 +1,1130 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; +import type { Bytes, Null, Option, Result, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { ITuple } from '@polkadot/types-codec/types'; +import type { EthereumAddress } from '@polkadot/types/interfaces/eth'; +import type { AccountId32, H256 } from '@polkadot/types/interfaces/runtime'; +import type { FrameSupportScheduleLookupError, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchInfo, PalletDemocracyVoteAccountVote, PalletDemocracyVoteThreshold, PalletElectionProviderMultiPhaseElectionCompute, PalletImOnlineSr25519AppSr25519Public, PalletMultisigTimepoint, PalletStakingExposure, PolkadotParachainPrimitivesHrmpChannelId, PolkadotPrimitivesV1CandidateReceipt, PolkadotRuntimeProxyType, SpFinalityGrandpaAppPublic, SpRuntimeDispatchError, XcmV1MultiLocation, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation } from '@polkadot/types/lookup'; + +declare module '@polkadot/api-base/types/events' { + export interface AugmentedEvents { + auctions: { + /** + * An auction ended. All funds become unreserved. `[auction_index]` + **/ + AuctionClosed: AugmentedEvent; + /** + * An auction started. Provides its index and the block number where it will begin to + * close and the first lease period of the quadruplet that is auctioned. + * `[auction_index, lease_period, ending]` + **/ + AuctionStarted: AugmentedEvent; + /** + * A new bid has been accepted as the current winner. + * `[who, para_id, amount, first_slot, last_slot]` + **/ + BidAccepted: AugmentedEvent; + /** + * Someone attempted to lease the same slot twice for a parachain. The amount is held in reserve + * but no parachain slot has been leased. + * `[parachain_id, leaser, amount]` + **/ + ReserveConfiscated: AugmentedEvent; + /** + * Funds were reserved for a winning bid. First balance is the extra amount reserved. + * Second is the total. `[bidder, extra_reserved, total_amount]` + **/ + Reserved: AugmentedEvent; + /** + * Funds were unreserved since bidder is no longer active. `[bidder, amount]` + **/ + Unreserved: AugmentedEvent; + /** + * The winning offset was chosen for an auction. This will map into the `Winning` storage map. + * `[auction_index, block_number]` + **/ + WinningOffset: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + bagsList: { + /** + * Moved an account from one bag to another. + **/ + Rebagged: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + balances: { + /** + * A balance was set by root. + **/ + BalanceSet: AugmentedEvent; + /** + * Some amount was deposited (e.g. for transaction fees). + **/ + Deposit: AugmentedEvent; + /** + * An account was removed whose balance was non-zero but below ExistentialDeposit, + * resulting in an outright loss. + **/ + DustLost: AugmentedEvent; + /** + * An account was created with some free balance. + **/ + Endowed: AugmentedEvent; + /** + * Some balance was reserved (moved from free to reserved). + **/ + Reserved: AugmentedEvent; + /** + * Some balance was moved from the reserve of the first account to the second account. + * Final argument indicates the destination balance type. + **/ + ReserveRepatriated: AugmentedEvent; + /** + * Some amount was removed from the account (e.g. for misbehavior). + **/ + Slashed: AugmentedEvent; + /** + * Transfer succeeded. + **/ + Transfer: AugmentedEvent; + /** + * Some balance was unreserved (moved from reserved to free). + **/ + Unreserved: AugmentedEvent; + /** + * Some amount was withdrawn from the account (e.g. for transaction fees). + **/ + Withdraw: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + bounties: { + /** + * A bounty is awarded to a beneficiary. + **/ + BountyAwarded: AugmentedEvent; + /** + * A bounty proposal is funded and became active. + **/ + BountyBecameActive: AugmentedEvent; + /** + * A bounty is cancelled. + **/ + BountyCanceled: AugmentedEvent; + /** + * A bounty is claimed by beneficiary. + **/ + BountyClaimed: AugmentedEvent; + /** + * A bounty expiry is extended. + **/ + BountyExtended: AugmentedEvent; + /** + * New bounty proposal. + **/ + BountyProposed: AugmentedEvent; + /** + * A bounty proposal was rejected; funds were slashed. + **/ + BountyRejected: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + claims: { + /** + * Someone claimed some DOTs. `[who, ethereum_address, amount]` + **/ + Claimed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + council: { + /** + * A motion was approved by the required threshold. + **/ + Approved: AugmentedEvent; + /** + * A proposal was closed because its threshold was reached or after its duration was up. + **/ + Closed: AugmentedEvent; + /** + * A motion was not approved by the required threshold. + **/ + Disapproved: AugmentedEvent; + /** + * A motion was executed; result will be `Ok` if it returned without error. + **/ + Executed: AugmentedEvent]>; + /** + * A single member did some action; result will be `Ok` if it returned without error. + **/ + MemberExecuted: AugmentedEvent]>; + /** + * A motion (given hash) has been proposed (by given account) with a threshold (given + * `MemberCount`). + **/ + Proposed: AugmentedEvent; + /** + * A motion (given hash) has been voted on by given account, leaving + * a tally (yes votes and no votes given respectively as `MemberCount`). + **/ + Voted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + crowdloan: { + /** + * A parachain has been moved to `NewRaise` + **/ + AddedToNewRaise: AugmentedEvent; + /** + * All loans in a fund have been refunded. `[fund_index]` + **/ + AllRefunded: AugmentedEvent; + /** + * Contributed to a crowd sale. `[who, fund_index, amount]` + **/ + Contributed: AugmentedEvent; + /** + * Create a new crowdloaning campaign. `[fund_index]` + **/ + Created: AugmentedEvent; + /** + * Fund is dissolved. `[fund_index]` + **/ + Dissolved: AugmentedEvent; + /** + * The configuration to a crowdloan has been edited. `[fund_index]` + **/ + Edited: AugmentedEvent; + /** + * The result of trying to submit a new bid to the Slots pallet. + **/ + HandleBidResult: AugmentedEvent]>; + /** + * A memo has been updated. `[who, fund_index, memo]` + **/ + MemoUpdated: AugmentedEvent; + /** + * The loans in a fund have been partially dissolved, i.e. there are some left + * over child keys that still need to be killed. `[fund_index]` + **/ + PartiallyRefunded: AugmentedEvent; + /** + * Withdrew full balance of a contributor. `[who, fund_index, amount]` + **/ + Withdrew: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + democracy: { + /** + * A proposal_hash has been blacklisted permanently. + **/ + Blacklisted: AugmentedEvent; + /** + * A referendum has been cancelled. + **/ + Cancelled: AugmentedEvent; + /** + * An account has delegated their vote to another account. + **/ + Delegated: AugmentedEvent; + /** + * A proposal has been enacted. + **/ + Executed: AugmentedEvent]>; + /** + * An external proposal has been tabled. + **/ + ExternalTabled: AugmentedEvent; + /** + * A proposal has been rejected by referendum. + **/ + NotPassed: AugmentedEvent; + /** + * A proposal has been approved by referendum. + **/ + Passed: AugmentedEvent; + /** + * A proposal could not be executed because its preimage was invalid. + **/ + PreimageInvalid: AugmentedEvent; + /** + * A proposal could not be executed because its preimage was missing. + **/ + PreimageMissing: AugmentedEvent; + /** + * A proposal's preimage was noted, and the deposit taken. + **/ + PreimageNoted: AugmentedEvent; + /** + * A registered preimage was removed and the deposit collected by the reaper. + **/ + PreimageReaped: AugmentedEvent; + /** + * A proposal preimage was removed and used (the deposit was returned). + **/ + PreimageUsed: AugmentedEvent; + /** + * A motion has been proposed by a public account. + **/ + Proposed: AugmentedEvent; + /** + * An account has secconded a proposal + **/ + Seconded: AugmentedEvent; + /** + * A referendum has begun. + **/ + Started: AugmentedEvent; + /** + * A public proposal has been tabled for referendum vote. + **/ + Tabled: AugmentedEvent]>; + /** + * An account has cancelled a previous delegation operation. + **/ + Undelegated: AugmentedEvent; + /** + * An external proposal has been vetoed. + **/ + Vetoed: AugmentedEvent; + /** + * An account has voted in a referendum + **/ + Voted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + electionProviderMultiPhase: { + /** + * The election has been finalized, with `Some` of the given computation, or else if the + * election failed, `None`. + **/ + ElectionFinalized: AugmentedEvent]>; + /** + * An account has been rewarded for their signed submission being finalized. + **/ + Rewarded: AugmentedEvent; + /** + * The signed phase of the given round has started. + **/ + SignedPhaseStarted: AugmentedEvent; + /** + * An account has been slashed for submitting an invalid signed submission. + **/ + Slashed: AugmentedEvent; + /** + * A solution was stored with the given compute. + * + * If the solution is signed, this means that it hasn't yet been processed. If the + * solution is unsigned, this means that it has also been processed. + * + * The `bool` is `true` when a previous solution was ejected to make room for this one. + **/ + SolutionStored: AugmentedEvent; + /** + * The unsigned phase of the given round has started. + **/ + UnsignedPhaseStarted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + grandpa: { + /** + * New authority set has been applied. + **/ + NewAuthorities: AugmentedEvent>]>; + /** + * Current authority set has been paused. + **/ + Paused: AugmentedEvent; + /** + * Current authority set has been resumed. + **/ + Resumed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + hrmp: { + /** + * HRMP channel closed. `[by_parachain, channel_id]` + **/ + ChannelClosed: AugmentedEvent; + /** + * Open HRMP channel accepted. `[sender, recipient]` + **/ + OpenChannelAccepted: AugmentedEvent; + /** + * An HRMP channel request sent by the receiver was canceled by either party. + * `[by_parachain, channel_id]` + **/ + OpenChannelCanceled: AugmentedEvent; + /** + * Open HRMP channel requested. + * `[sender, recipient, proposed_max_capacity, proposed_max_message_size]` + **/ + OpenChannelRequested: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + identity: { + /** + * A name was cleared, and the given balance returned. + **/ + IdentityCleared: AugmentedEvent; + /** + * A name was removed and the given balance slashed. + **/ + IdentityKilled: AugmentedEvent; + /** + * A name was set or reset (which will remove all judgements). + **/ + IdentitySet: AugmentedEvent; + /** + * A judgement was given by a registrar. + **/ + JudgementGiven: AugmentedEvent; + /** + * A judgement was asked from a registrar. + **/ + JudgementRequested: AugmentedEvent; + /** + * A judgement request was retracted. + **/ + JudgementUnrequested: AugmentedEvent; + /** + * A registrar was added. + **/ + RegistrarAdded: AugmentedEvent; + /** + * A sub-identity was added to an identity and the deposit paid. + **/ + SubIdentityAdded: AugmentedEvent; + /** + * A sub-identity was removed from an identity and the deposit freed. + **/ + SubIdentityRemoved: AugmentedEvent; + /** + * A sub-identity was cleared, and the given deposit repatriated from the + * main identity account to the sub-identity account. + **/ + SubIdentityRevoked: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + imOnline: { + /** + * At the end of the session, no offence was committed. + **/ + AllGood: AugmentedEvent; + /** + * A new heartbeat was received from `AuthorityId`. + **/ + HeartbeatReceived: AugmentedEvent; + /** + * At the end of the session, at least one validator was found to be offline. + **/ + SomeOffline: AugmentedEvent>]>; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + indices: { + /** + * A account index was assigned. + **/ + IndexAssigned: AugmentedEvent; + /** + * A account index has been freed up (unassigned). + **/ + IndexFreed: AugmentedEvent; + /** + * A account index has been frozen to its current account ID. + **/ + IndexFrozen: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + multisig: { + /** + * A multisig operation has been approved by someone. + **/ + MultisigApproval: AugmentedEvent; + /** + * A multisig operation has been cancelled. + **/ + MultisigCancelled: AugmentedEvent; + /** + * A multisig operation has been executed. + **/ + MultisigExecuted: AugmentedEvent]>; + /** + * A new multisig operation has begun. + **/ + NewMultisig: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + offences: { + /** + * There is an offence reported of the given `kind` happened at the `session_index` and + * (kind-specific) time slot. This event is not deposited for duplicate slashes. + * \[kind, timeslot\]. + **/ + Offence: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + paraInclusion: { + /** + * A candidate was backed. `[candidate, head_data]` + **/ + CandidateBacked: AugmentedEvent; + /** + * A candidate was included. `[candidate, head_data]` + **/ + CandidateIncluded: AugmentedEvent; + /** + * A candidate timed out. `[candidate, head_data]` + **/ + CandidateTimedOut: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + paras: { + /** + * A para has been queued to execute pending actions. `para_id` + **/ + ActionQueued: AugmentedEvent; + /** + * A code upgrade has been scheduled for a Para. `para_id` + **/ + CodeUpgradeScheduled: AugmentedEvent; + /** + * Current code has been updated for a Para. `para_id` + **/ + CurrentCodeUpdated: AugmentedEvent; + /** + * Current head has been updated for a Para. `para_id` + **/ + CurrentHeadUpdated: AugmentedEvent; + /** + * A new head has been noted for a Para. `para_id` + **/ + NewHeadNoted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + phragmenElection: { + /** + * A candidate was slashed by amount due to failing to obtain a seat as member or + * runner-up. + * + * Note that old members and runners-up are also candidates. + **/ + CandidateSlashed: AugmentedEvent; + /** + * Internal error happened while trying to perform election. + **/ + ElectionError: AugmentedEvent; + /** + * No (or not enough) candidates existed for this round. This is different from + * `NewTerm(\[\])`. See the description of `NewTerm`. + **/ + EmptyTerm: AugmentedEvent; + /** + * A member has been removed. This should always be followed by either `NewTerm` or + * `EmptyTerm`. + **/ + MemberKicked: AugmentedEvent; + /** + * A new term with new_members. This indicates that enough candidates existed to run + * the election, not that enough have has been elected. The inner value must be examined + * for this purpose. A `NewTerm(\[\])` indicates that some candidates got their bond + * slashed and none were elected, whilst `EmptyTerm` means that no candidates existed to + * begin with. + **/ + NewTerm: AugmentedEvent>]>; + /** + * Someone has renounced their candidacy. + **/ + Renounced: AugmentedEvent; + /** + * A seat holder was slashed by amount by being forcefully removed from the set. + **/ + SeatHolderSlashed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + preimage: { + /** + * A preimage has ben cleared. + **/ + Cleared: AugmentedEvent; + /** + * A preimage has been noted. + **/ + Noted: AugmentedEvent; + /** + * A preimage has been requested. + **/ + Requested: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + proxy: { + /** + * An announcement was placed to make a call in the future. + **/ + Announced: AugmentedEvent; + /** + * Anonymous account has been created by new proxy with given + * disambiguation index and proxy type. + **/ + AnonymousCreated: AugmentedEvent; + /** + * A proxy was added. + **/ + ProxyAdded: AugmentedEvent; + /** + * A proxy was executed correctly, with the given. + **/ + ProxyExecuted: AugmentedEvent]>; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + registrar: { + Deregistered: AugmentedEvent; + Registered: AugmentedEvent; + Reserved: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + scheduler: { + /** + * The call for the provided hash was not found so the task has been aborted. + **/ + CallLookupFailed: AugmentedEvent, Option, FrameSupportScheduleLookupError]>; + /** + * Canceled some task. + **/ + Canceled: AugmentedEvent; + /** + * Dispatched some task. + **/ + Dispatched: AugmentedEvent, Option, Result]>; + /** + * Scheduled some task. + **/ + Scheduled: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + session: { + /** + * New session has happened. Note that the argument is the session index, not the + * block number as the type might suggest. + **/ + NewSession: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + slots: { + /** + * A para has won the right to a continuous set of lease periods as a parachain. + * First balance is any extra amount reserved on top of the para's existing deposit. + * Second balance is the total amount reserved. + * `[parachain_id, leaser, period_begin, period_count, extra_reserved, total_amount]` + **/ + Leased: AugmentedEvent; + /** + * A new `[lease_period]` is beginning. + **/ + NewLeasePeriod: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + staking: { + /** + * An account has bonded this amount. \[stash, amount\] + * + * NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably, + * it will not be emitted for staking rewards when they are added to stake. + **/ + Bonded: AugmentedEvent; + /** + * An account has stopped participating as either a validator or nominator. + * \[stash\] + **/ + Chilled: AugmentedEvent; + /** + * The era payout has been set; the first balance is the validator-payout; the second is + * the remainder from the maximum amount of reward. + * \[era_index, validator_payout, remainder\] + **/ + EraPaid: AugmentedEvent; + /** + * A nominator has been kicked from a validator. \[nominator, stash\] + **/ + Kicked: AugmentedEvent; + /** + * An old slashing report from a prior era was discarded because it could + * not be processed. \[session_index\] + **/ + OldSlashingReportDiscarded: AugmentedEvent; + /** + * The stakers' rewards are getting paid. \[era_index, validator_stash\] + **/ + PayoutStarted: AugmentedEvent; + /** + * The nominator has been rewarded by this amount. \[stash, amount\] + **/ + Rewarded: AugmentedEvent; + /** + * One validator (and its nominators) has been slashed by the given amount. + * \[validator, amount\] + **/ + Slashed: AugmentedEvent; + /** + * A new set of stakers was elected. + **/ + StakersElected: AugmentedEvent; + /** + * The election failed. No new era is planned. + **/ + StakingElectionFailed: AugmentedEvent; + /** + * An account has unbonded this amount. \[stash, amount\] + **/ + Unbonded: AugmentedEvent; + /** + * An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance` + * from the unlocking queue. \[stash, amount\] + **/ + Withdrawn: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + system: { + /** + * `:code` was updated. + **/ + CodeUpdated: AugmentedEvent; + /** + * An extrinsic failed. + **/ + ExtrinsicFailed: AugmentedEvent; + /** + * An extrinsic completed successfully. + **/ + ExtrinsicSuccess: AugmentedEvent; + /** + * An account was reaped. + **/ + KilledAccount: AugmentedEvent; + /** + * A new account was created. + **/ + NewAccount: AugmentedEvent; + /** + * On on-chain remark happened. + **/ + Remarked: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + technicalCommittee: { + /** + * A motion was approved by the required threshold. + **/ + Approved: AugmentedEvent; + /** + * A proposal was closed because its threshold was reached or after its duration was up. + **/ + Closed: AugmentedEvent; + /** + * A motion was not approved by the required threshold. + **/ + Disapproved: AugmentedEvent; + /** + * A motion was executed; result will be `Ok` if it returned without error. + **/ + Executed: AugmentedEvent]>; + /** + * A single member did some action; result will be `Ok` if it returned without error. + **/ + MemberExecuted: AugmentedEvent]>; + /** + * A motion (given hash) has been proposed (by given account) with a threshold (given + * `MemberCount`). + **/ + Proposed: AugmentedEvent; + /** + * A motion (given hash) has been voted on by given account, leaving + * a tally (yes votes and no votes given respectively as `MemberCount`). + **/ + Voted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + technicalMembership: { + /** + * Phantom member, never used. + **/ + Dummy: AugmentedEvent; + /** + * One of the members' keys changed. + **/ + KeyChanged: AugmentedEvent; + /** + * The given member was added; see the transaction for who. + **/ + MemberAdded: AugmentedEvent; + /** + * The given member was removed; see the transaction for who. + **/ + MemberRemoved: AugmentedEvent; + /** + * The membership was reset; see the transaction for who the new set is. + **/ + MembersReset: AugmentedEvent; + /** + * Two members were swapped; see the transaction for who. + **/ + MembersSwapped: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + tips: { + /** + * A new tip suggestion has been opened. + **/ + NewTip: AugmentedEvent; + /** + * A tip suggestion has been closed. + **/ + TipClosed: AugmentedEvent; + /** + * A tip suggestion has reached threshold and is closing. + **/ + TipClosing: AugmentedEvent; + /** + * A tip suggestion has been retracted. + **/ + TipRetracted: AugmentedEvent; + /** + * A tip suggestion has been slashed. + **/ + TipSlashed: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + treasury: { + /** + * Some funds have been allocated. + **/ + Awarded: AugmentedEvent; + /** + * Some of our funds have been burnt. + **/ + Burnt: AugmentedEvent; + /** + * Some funds have been deposited. + **/ + Deposit: AugmentedEvent; + /** + * New proposal. + **/ + Proposed: AugmentedEvent; + /** + * A proposal was rejected; funds were slashed. + **/ + Rejected: AugmentedEvent; + /** + * Spending has finished; this is the amount that rolls over until next spend. + **/ + Rollover: AugmentedEvent; + /** + * We have ended a spend period and will now allocate funds. + **/ + Spending: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + ump: { + /** + * Upward message executed with the given outcome. + * \[ id, outcome \] + **/ + ExecutedUpward: AugmentedEvent; + /** + * Upward message is invalid XCM. + * \[ id \] + **/ + InvalidFormat: AugmentedEvent; + /** + * The weight budget was exceeded for an individual upward message. + * + * This message can be later dispatched manually using `service_overweight` dispatchable + * using the assigned `overweight_index`. + * + * \[ para, id, overweight_index, required \] + **/ + OverweightEnqueued: AugmentedEvent; + /** + * Upward message from the overweight queue was executed with the given actual weight + * used. + * + * \[ overweight_index, used \] + **/ + OverweightServiced: AugmentedEvent; + /** + * Upward message is unsupported version of XCM. + * \[ id \] + **/ + UnsupportedVersion: AugmentedEvent; + /** + * Some upward messages have been received and will be processed. + * \[ para, count, size \] + **/ + UpwardMessagesReceived: AugmentedEvent; + /** + * The weight limit for handling upward messages was reached. + * \[ id, remaining, required \] + **/ + WeightExhausted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + utility: { + /** + * Batch of dispatches completed fully with no error. + **/ + BatchCompleted: AugmentedEvent; + /** + * Batch of dispatches did not complete fully. Index of first failing dispatch given, as + * well as the error. + **/ + BatchInterrupted: AugmentedEvent; + /** + * A call was dispatched. + **/ + DispatchedAs: AugmentedEvent]>; + /** + * A single item within a Batch of dispatches has completed with no error. + **/ + ItemCompleted: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + vesting: { + /** + * An \[account\] has become fully vested. + **/ + VestingCompleted: AugmentedEvent; + /** + * The amount vested has been updated. This could indicate a change in funds available. + * The balance given is the amount which is left unvested (and thus locked). + **/ + VestingUpdated: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + xcmPallet: { + /** + * Some assets have been placed in an asset trap. + * + * \[ hash, origin, assets \] + **/ + AssetsTrapped: AugmentedEvent; + /** + * Execution of an XCM message was attempted. + * + * \[ outcome \] + **/ + Attempted: AugmentedEvent; + /** + * Expected query response has been received but the origin location of the response does + * not match that expected. The query remains registered for a later, valid, response to + * be received and acted upon. + * + * \[ origin location, id, expected location \] + **/ + InvalidResponder: AugmentedEvent]>; + /** + * Expected query response has been received but the expected origin location placed in + * storage by this runtime previously cannot be decoded. The query remains registered. + * + * This is unexpected (since a location placed in storage in a previously executing + * runtime should be readable prior to query timeout) and dangerous since the possibly + * valid response will be dropped. Manual governance intervention is probably going to be + * needed. + * + * \[ origin location, id \] + **/ + InvalidResponderVersion: AugmentedEvent; + /** + * Query response has been received and query is removed. The registered notification has + * been dispatched and executed successfully. + * + * \[ id, pallet index, call index \] + **/ + Notified: AugmentedEvent; + /** + * Query response has been received and query is removed. The dispatch was unable to be + * decoded into a `Call`; this might be due to dispatch function having a signature which + * is not `(origin, QueryId, Response)`. + * + * \[ id, pallet index, call index \] + **/ + NotifyDecodeFailed: AugmentedEvent; + /** + * Query response has been received and query is removed. There was a general error with + * dispatching the notification call. + * + * \[ id, pallet index, call index \] + **/ + NotifyDispatchError: AugmentedEvent; + /** + * Query response has been received and query is removed. The registered notification could + * not be dispatched because the dispatch weight is greater than the maximum weight + * originally budgeted by this runtime for the query result. + * + * \[ id, pallet index, call index, actual weight, max budgeted weight \] + **/ + NotifyOverweight: AugmentedEvent; + /** + * A given location which had a version change subscription was dropped owing to an error + * migrating the location to our new XCM format. + * + * \[ location, query ID \] + **/ + NotifyTargetMigrationFail: AugmentedEvent; + /** + * A given location which had a version change subscription was dropped owing to an error + * sending the notification to it. + * + * \[ location, query ID, error \] + **/ + NotifyTargetSendFail: AugmentedEvent; + /** + * Query response has been received and is ready for taking with `take_response`. There is + * no registered notification call. + * + * \[ id, response \] + **/ + ResponseReady: AugmentedEvent; + /** + * Received query response has been read and removed. + * + * \[ id \] + **/ + ResponseTaken: AugmentedEvent; + /** + * A XCM message was sent. + * + * \[ origin, destination, message \] + **/ + Sent: AugmentedEvent; + /** + * The supported version of a location has been changed. This might be through an + * automatic notification or a manual intervention. + * + * \[ location, XCM version \] + **/ + SupportedVersionChanged: AugmentedEvent; + /** + * Query response received which does not match a registered query. This may be because a + * matching query was never registered, it may be because it is a duplicate response, or + * because the query timed out. + * + * \[ origin location, id \] + **/ + UnexpectedResponse: AugmentedEvent; + /** + * An XCM version change notification message has been attempted to be sent. + * + * \[ destination, result \] + **/ + VersionChangeNotified: AugmentedEvent; + /** + * Generic event + **/ + [key: string]: AugmentedEvent; + }; + } // AugmentedEvents +} // declare module diff --git a/packages/api-augment/src/polkadot/index.ts b/packages/api-augment/src/polkadot/index.ts new file mode 100644 index 0000000000..54df49bcd9 --- /dev/null +++ b/packages/api-augment/src/polkadot/index.ts @@ -0,0 +1,9 @@ +// Copyright 2017-2021 @polkadot/api-augment authors & contributors +// SPDX-License-Identifier: Apache-2.0 + +import '../base'; +import './consts'; +import './errors'; +import './events'; +import './query'; +import './tx'; diff --git a/packages/api-augment/src/polkadot/query.ts b/packages/api-augment/src/polkadot/query.ts new file mode 100644 index 0000000000..4fddab3c42 --- /dev/null +++ b/packages/api-augment/src/polkadot/query.ts @@ -0,0 +1,1738 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; +import type { Data } from '@polkadot/types'; +import type { BTreeMap, Bytes, Null, Option, U8aFixed, Vec, WrapperOpaque, bool, u128, u32, u64 } from '@polkadot/types-codec'; +import type { AnyNumber, ITuple } from '@polkadot/types-codec/types'; +import type { EthereumAddress } from '@polkadot/types/interfaces/eth'; +import type { AccountId32, Call, H256, Perbill, Percent } from '@polkadot/types/interfaces/runtime'; +import type { FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, PalletAuthorshipUncleEntryItem, PalletBagsListListBag, PalletBagsListListNode, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletBountiesBounty, PalletCollectiveVotes, PalletDemocracyPreimageStatus, PalletDemocracyReferendumInfo, PalletDemocracyReleases, PalletDemocracyVoteThreshold, PalletDemocracyVoteVoting, PalletElectionProviderMultiPhasePhase, PalletElectionProviderMultiPhaseReadySolution, PalletElectionProviderMultiPhaseRoundSnapshot, PalletElectionProviderMultiPhaseSignedSignedSubmission, PalletElectionProviderMultiPhaseSolutionOrSnapshotSize, PalletElectionsPhragmenSeatHolder, PalletElectionsPhragmenVoter, PalletGrandpaStoredPendingChange, PalletGrandpaStoredState, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletImOnlineBoundedOpaqueNetworkState, PalletImOnlineSr25519AppSr25519Public, PalletMultisigMultisig, PalletPreimageRequestStatus, PalletProxyAnnouncement, PalletProxyProxyDefinition, PalletSchedulerReleases, PalletSchedulerScheduledV3, PalletStakingActiveEraInfo, PalletStakingEraRewardPoints, PalletStakingExposure, PalletStakingForcing, PalletStakingNominations, PalletStakingReleases, PalletStakingRewardDestination, PalletStakingSlashingSlashingSpans, PalletStakingSlashingSpanRecord, PalletStakingStakingLedger, PalletStakingUnappliedSlash, PalletStakingValidatorPrefs, PalletTipsOpenTip, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletVestingReleases, PalletVestingVestingInfo, PalletXcmQueryStatus, PalletXcmVersionMigrationStage, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotParachainPrimitivesHrmpChannelId, PolkadotPrimitivesV0ValidatorAppPublic, PolkadotPrimitivesV1AssignmentAppPublic, PolkadotPrimitivesV1CandidateCommitments, PolkadotPrimitivesV1CoreOccupied, PolkadotPrimitivesV1ScrapedOnChainVotes, PolkadotPrimitivesV1SessionInfo, PolkadotPrimitivesV1UpgradeGoAhead, PolkadotPrimitivesV1UpgradeRestriction, PolkadotRuntimeCommonClaimsStatementKind, PolkadotRuntimeCommonCrowdloanFundInfo, PolkadotRuntimeCommonParasRegistrarParaInfo, PolkadotRuntimeParachainsConfigurationHostConfiguration, PolkadotRuntimeParachainsHrmpHrmpChannel, PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest, PolkadotRuntimeParachainsInclusionAvailabilityBitfieldRecord, PolkadotRuntimeParachainsInclusionCandidatePendingAvailability, PolkadotRuntimeParachainsInitializerBufferedSessionChange, PolkadotRuntimeParachainsParasParaGenesisArgs, PolkadotRuntimeParachainsParasParaLifecycle, PolkadotRuntimeParachainsParasParaPastCodeMeta, PolkadotRuntimeParachainsParasPvfCheckActiveVoteState, PolkadotRuntimeParachainsSchedulerCoreAssignment, PolkadotRuntimeParachainsSchedulerParathreadClaimQueue, PolkadotRuntimeSessionKeys, SpConsensusBabeAppPublic, SpConsensusBabeBabeEpochConfiguration, SpConsensusBabeDigestsNextConfigDescriptor, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpStakingOffenceOffenceDetails, XcmVersionedMultiLocation } from '@polkadot/types/lookup'; +import type { Observable } from '@polkadot/types/types'; + +declare module '@polkadot/api-base/types/storage' { + export interface AugmentedQueries { + auctions: { + /** + * Number of auctions started so far. + **/ + auctionCounter: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Information relating to the current auction, if there is one. + * + * The first item in the tuple is the lease period index that the first of the four + * contiguous lease periods on auction is for. The second is the block number when the + * auction will "begin to end", i.e. the first block of the Ending Period of the auction. + **/ + auctionInfo: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Amounts currently reserved in the accounts of the bidders currently winning + * (sub-)ranges. + **/ + reservedAmounts: AugmentedQuery | [AccountId32 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable>, [ITuple<[AccountId32, u32]>]> & QueryableStorageEntry]>; + /** + * The winning bids for each of the 10 ranges at each sample in the final Ending Period of + * the current auction. The map's key is the 0-based index into the Sample Size. The + * first sample of the ending period is 0; the last is `Sample Size - 1`. + **/ + winning: AugmentedQuery Observable>>>>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + authorship: { + /** + * Author of current block. + **/ + author: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Whether uncles were already set in this block. + **/ + didSetUncles: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Uncles + **/ + uncles: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + babe: { + /** + * Current epoch authorities. + **/ + authorities: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * This field should always be populated during block processing unless + * secondary plain slots are enabled (which don't contain a VRF output). + * + * It is set in `on_initialize`, before it will contain the value from the last block. + **/ + authorVrfRandomness: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Current slot number. + **/ + currentSlot: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The configuration for the current epoch. Should never be `None` as it is initialized in + * genesis. + **/ + epochConfig: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Current epoch index. + **/ + epochIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The block numbers when the last and current epoch have started, respectively `N-1` and + * `N`. + * NOTE: We track this is in order to annotate the block number when a given pool of + * entropy was fixed (i.e. it was known to chain observers). Since epochs are defined in + * slots, which may be skipped, the block numbers may not line up with the slot numbers. + **/ + epochStart: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The slot at which the first epoch actually started. This is 0 + * until the first block of the chain. + **/ + genesisSlot: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Temporary value (cleared at block finalization) which is `Some` + * if per-block initialization has already been called for current block. + **/ + initialized: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * How late the current block is compared to its parent. + * + * This entry is populated as part of block execution and is cleaned up + * on block finalization. Querying this storage entry outside of block + * execution context should always yield zero. + **/ + lateness: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Next epoch authorities. + **/ + nextAuthorities: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The configuration for the next epoch, `None` if the config will not change + * (you can fallback to `EpochConfig` instead in that case). + **/ + nextEpochConfig: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Next epoch randomness. + **/ + nextRandomness: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Pending epoch configuration change that will be applied when the next epoch is enacted. + **/ + pendingEpochConfigChange: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The epoch randomness for the *current* epoch. + * + * # Security + * + * This MUST NOT be used for gambling, as it can be influenced by a + * malicious validator in the short term. It MAY be used in many + * cryptographic protocols, however, so long as one remembers that this + * (like everything else on-chain) it is public. For example, it can be + * used where a number is needed that cannot have been chosen by an + * adversary, for purposes such as public-coin zero-knowledge proofs. + **/ + randomness: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Randomness under construction. + * + * We make a trade-off between storage accesses and list length. + * We store the under-construction randomness in segments of up to + * `UNDER_CONSTRUCTION_SEGMENT_LENGTH`. + * + * Once a segment reaches this length, we begin the next one. + * We reset all segments and return to `0` at the beginning of every + * epoch. + **/ + segmentIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay. + **/ + underConstruction: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + bagsList: { + /** + * Counter for the related counted storage map + **/ + counterForListNodes: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * A bag stored in storage. + * + * Stores a `Bag` struct, which stores head and tail pointers to itself. + **/ + listBags: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + /** + * A single node, within some bag. + * + * Nodes store links forward and back within their respective bags. + **/ + listNodes: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + balances: { + /** + * The balance of an account. + * + * NOTE: This is only used in the case that this pallet is used to store balances. + **/ + account: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Any liquidity locks on some account balances. + * NOTE: Should only be accessed when setting, changing and freeing a lock. + **/ + locks: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Named reserves on some account balances. + **/ + reserves: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * Storage version of the pallet. + * + * This is set to v2.0.0 for new networks. + **/ + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The total units issued in the system. + **/ + totalIssuance: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + bounties: { + /** + * Bounties that have been made. + **/ + bounties: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Bounty indices that have been approved but not yet funded. + **/ + bountyApprovals: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Number of bounty proposals that have been made. + **/ + bountyCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The description of each bounty. + **/ + bountyDescriptions: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + claims: { + claims: AugmentedQuery Observable>, [EthereumAddress]> & QueryableStorageEntry; + /** + * Pre-claimed Ethereum accounts, by the Account ID that they are claimed to. + **/ + preclaims: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The statement kind that must be signed, if any. + **/ + signing: AugmentedQuery Observable>, [EthereumAddress]> & QueryableStorageEntry; + total: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Vesting schedule for a claim. + * First balance is the total amount that should be held for vesting. + * Second balance is how much should be unlocked per block. + * The block number is when the vesting should start. + **/ + vesting: AugmentedQuery Observable>>, [EthereumAddress]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + configuration: { + /** + * The active configuration for the current session. + **/ + activeConfig: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Pending configuration (if any) for the next session. + **/ + pendingConfig: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + council: { + /** + * The current members of the collective. This is stored sorted (just by value). + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The prime member that helps determine the default vote behavior in case of absentations. + **/ + prime: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Proposals so far. + **/ + proposalCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Actual proposal for a given hash, if it's current. + **/ + proposalOf: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The hashes of the active proposals. + **/ + proposals: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Votes on a given proposal, if it is ongoing. + **/ + voting: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + crowdloan: { + /** + * The number of auctions that have entered into their ending period so far. + **/ + endingsCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Info on all of the funds. + **/ + funds: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The funds that have had additional contributions during the last block. This is used + * in order to determine which funds should submit new or updated bids. + **/ + newRaise: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Tracker for the next available trie index + **/ + nextTrieIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + democracy: { + /** + * 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: AugmentedQuery Observable]>>>, [H256]> & QueryableStorageEntry; + /** + * Record of all proposals that have been subject to emergency cancellation. + **/ + cancellations: AugmentedQuery Observable, [H256]> & QueryableStorageEntry; + /** + * Those who have locked a deposit. + * + * TWOX-NOTE: Safe, as increasing integer keys are safe. + **/ + depositOf: AugmentedQuery Observable, u128]>>>, [u32]> & QueryableStorageEntry; + /** + * True if the last referendum tabled was submitted externally. False if it was a public + * proposal. + **/ + lastTabledWasExternal: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Accounts for which there are locks in action which may be removed at some point in the + * future. The value is the block number at which the lock expires and may be removed. + * + * TWOX-NOTE: OK ― `AccountId` is a secure hash. + **/ + locks: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The lowest referendum index representing an unbaked referendum. Equal to + * `ReferendumCount` if there isn't a unbaked referendum. + **/ + lowestUnbaked: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Map of hashes to the proposal preimage, along with who registered it and their deposit. + * The block number is the block at which it was deposited. + **/ + preimages: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The number of (public) proposals that have been made so far. + **/ + publicPropCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The public proposals. Unsorted. The second item is the proposal's hash. + **/ + publicProps: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The next free referendum index, aka the number of referenda started so far. + **/ + referendumCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Information concerning any given referendum. + * + * TWOX-NOTE: SAFE as indexes are not under an attacker’s control. + **/ + referendumInfoOf: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Storage version of the pallet. + * + * New networks start with last version. + **/ + storageVersion: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + dmp: { + /** + * A mapping that stores the downward message queue MQC head for each para. + * + * Each link in this chain has a form: + * `(prev_head, B, H(M))`, where + * - `prev_head`: is the previous head hash or zero if none. + * - `B`: is the relay-chain block number in which a message was appended. + * - `H(M)`: is the hash of the message being appended. + **/ + downwardMessageQueueHeads: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * The downward messages addressed for a certain para. + **/ + downwardMessageQueues: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + electionProviderMultiPhase: { + /** + * Current phase. + **/ + currentPhase: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Desired number of targets to elect for this round. + * + * Only exists when [`Snapshot`] is present. + **/ + desiredTargets: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The minimum score that each 'untrusted' solution must attain in order to be considered + * feasible. + * + * Can be set via `set_minimum_untrusted_score`. + **/ + minimumUntrustedScore: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Current best solution, signed or unsigned, queued to be returned upon `elect`. + **/ + queuedSolution: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Internal counter for the number of rounds. + * + * This is useful for de-duplication of transactions submitted to the pool, and general + * diagnostics of the pallet. + * + * This is merely incremented once per every time that an upstream `elect` is called. + **/ + round: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * A sorted, bounded set of `(score, index)`, where each `index` points to a value in + * `SignedSubmissions`. + * + * We never need to process more than a single signed submission at a time. Signed submissions + * can be quite large, so we're willing to pay the cost of multiple database accesses to access + * them one at a time instead of reading and decoding all of them at once. + **/ + signedSubmissionIndices: AugmentedQuery Observable, u32>>, []> & QueryableStorageEntry; + /** + * The next index to be assigned to an incoming signed submission. + * + * Every accepted submission is assigned a unique index; that index is bound to that particular + * submission for the duration of the election. On election finalization, the next index is + * reset to 0. + * + * We can't just use `SignedSubmissionIndices.len()`, because that's a bounded set; past its + * capacity, it will simply saturate. We can't just iterate over `SignedSubmissionsMap`, + * because iteration is slow. Instead, we store the value here. + **/ + signedSubmissionNextIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Unchecked, signed solutions. + * + * Together with `SubmissionIndices`, this stores a bounded set of `SignedSubmissions` while + * allowing us to keep only a single one in memory at a time. + * + * Twox note: the key of the map is an auto-incrementing index which users cannot inspect or + * affect; we shouldn't need a cryptographically secure hasher. + **/ + signedSubmissionsMap: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Snapshot data of the round. + * + * This is created at the beginning of the signed phase and cleared upon calling `elect`. + **/ + snapshot: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The metadata of the [`RoundSnapshot`] + * + * Only exists when [`Snapshot`] is present. + **/ + snapshotMetadata: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + grandpa: { + /** + * The number of changes (both in terms of keys and underlying economic responsibilities) + * in the "set" of Grandpa validators from genesis. + **/ + currentSetId: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * next block number where we can force a change. + **/ + nextForced: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Pending change: (signaled at, scheduled change). + **/ + pendingChange: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * A mapping from grandpa set ID to the index of the *most recent* session for which its + * members were responsible. + * + * TWOX-NOTE: `SetId` is not under user control. + **/ + setIdSession: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + /** + * `true` if we are currently stalled. + **/ + stalled: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * State of the current authority set. + **/ + state: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + hrmp: { + /** + * This mapping tracks how many open channel requests were accepted by a given recipient para. + * Invariant: `HrmpOpenChannelRequests` should contain the same number of items `(_, X)` with + * `confirmed` set to true, as the number of `HrmpAcceptedChannelRequestCount` for `X`. + **/ + hrmpAcceptedChannelRequestCount: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Storage for the messages for each channel. + * Invariant: cannot be non-empty if the corresponding channel in `HrmpChannels` is `None`. + **/ + hrmpChannelContents: AugmentedQuery Observable>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry; + /** + * Maintains a mapping that can be used to answer the question: + * What paras sent a message at the given block number for a given receiver. + * Invariants: + * - The inner `Vec` is never empty. + * - The inner `Vec` cannot store two same `ParaId`. + * - The outer vector is sorted ascending by block number and cannot store two items with the same + * block number. + **/ + hrmpChannelDigests: AugmentedQuery Observable]>>>, [u32]> & QueryableStorageEntry; + /** + * HRMP channel data associated with each para. + * Invariant: + * - each participant in the channel should satisfy `Paras::is_valid_para(P)` within a session. + **/ + hrmpChannels: AugmentedQuery Observable>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry; + /** + * A set of pending HRMP close channel requests that are going to be closed during the session change. + * Used for checking if a given channel is registered for closure. + * + * The set is accompanied by a list for iteration. + * + * Invariant: + * - There are no channels that exists in list but not in the set and vice versa. + **/ + hrmpCloseChannelRequests: AugmentedQuery Observable>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry; + hrmpCloseChannelRequestsList: AugmentedQuery Observable>, []> & QueryableStorageEntry; + hrmpEgressChannelsIndex: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Ingress/egress indexes allow to find all the senders and receivers given the opposite + * side. I.e. + * + * (a) ingress index allows to find all the senders for a given recipient. + * (b) egress index allows to find all the recipients for a given sender. + * + * Invariants: + * - for each ingress index entry for `P` each item `I` in the index should present in `HrmpChannels` + * as `(I, P)`. + * - for each egress index entry for `P` each item `E` in the index should present in `HrmpChannels` + * as `(P, E)`. + * - there should be no other dangling channels in `HrmpChannels`. + * - the vectors are sorted. + **/ + hrmpIngressChannelsIndex: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * This mapping tracks how many open channel requests are initiated by a given sender para. + * Invariant: `HrmpOpenChannelRequests` should contain the same number of items that has `(X, _)` + * as the number of `HrmpOpenChannelRequestCount` for `X`. + **/ + hrmpOpenChannelRequestCount: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * The set of pending HRMP open channel requests. + * + * The set is accompanied by a list for iteration. + * + * Invariant: + * - There are no channels that exists in list but not in the set and vice versa. + **/ + hrmpOpenChannelRequests: AugmentedQuery Observable>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry; + hrmpOpenChannelRequestsList: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The HRMP watermark associated with each para. + * Invariant: + * - each para `P` used here as a key should satisfy `Paras::is_valid_para(P)` within a session. + **/ + hrmpWatermarks: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + identity: { + /** + * Information that is pertinent to identify the entity behind an account. + * + * TWOX-NOTE: OK ― `AccountId` is a secure hash. + **/ + identityOf: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable]>>, [AccountId32]> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable>>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + imOnline: { + /** + * For each session index, we keep a mapping of `ValidatorId` to the + * number of blocks authored by the given authority. + **/ + authoredBlocks: AugmentedQuery Observable, [u32, AccountId32]> & QueryableStorageEntry; + /** + * The block number after which it's ok to send heartbeats in the current + * session. + * + * At the beginning of each session we set this to a value that should fall + * roughly in the middle of the session duration. The idea is to first wait for + * the validators to produce a block in the current session, so that the + * heartbeat later on will not be necessary. + * + * This value will only be used as a fallback if we fail to get a proper session + * progress estimate from `NextSessionRotation`, as those estimates should be + * more accurate then the value we calculate for `HeartbeatAfter`. + **/ + heartbeatAfter: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The current set of keys that may issue a heartbeat. + **/ + keys: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * For each session index, we keep a mapping of `SessionIndex` and `AuthIndex` to + * `WrapperOpaque`. + **/ + receivedHeartbeats: AugmentedQuery Observable>>, [u32, u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + indices: { + /** + * The lookup from index to account. + **/ + accounts: AugmentedQuery Observable>>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + initializer: { + /** + * Buffered session changes along with the block number at which they should be applied. + * + * Typically this will be empty or one element long. Apart from that this item never hits + * the storage. + * + * However this is a `Vec` regardless to handle various edge cases that may occur at runtime + * upgrade boundaries or if governance intervenes. + **/ + bufferedSessionChanges: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Whether the parachains modules have been initialized within this block. + * + * Semantically a `bool`, but this guarantees it should never hit the trie, + * as this is cleared in `on_finalize` and Frame optimizes `None` values to be empty values. + * + * As a `bool`, `set(false)` and `remove()` both lead to the next `get()` being false, but one of + * them writes to the trie and one does not. This confusion makes `Option<()>` more suitable for + * the semantics of this variable. + **/ + hasInitialized: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + multisig: { + calls: AugmentedQuery Observable>>, [U8aFixed]> & QueryableStorageEntry; + /** + * The set of open multisig operations. + **/ + multisigs: AugmentedQuery Observable>, [AccountId32, U8aFixed]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + offences: { + /** + * A vector of reports of the same kind that happened at the same time slot. + **/ + concurrentReportsIndex: AugmentedQuery Observable>, [U8aFixed, Bytes]> & QueryableStorageEntry; + /** + * The primary structure that holds all offence records keyed by report identifiers. + **/ + reports: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Enumerates all reports of a kind along with the time they happened. + * + * All reports are sorted by the time of offence. + * + * Note that the actual type of this mapping is `Vec`, this is because values of + * different types are not supported at the moment so we are doing the manual serialization. + **/ + reportsByKindIndex: AugmentedQuery Observable, [U8aFixed]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paraInclusion: { + /** + * The latest bitfield for each validator, referred to by their index in the validator set. + **/ + availabilityBitfields: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Candidates pending availability by `ParaId`. + **/ + pendingAvailability: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The commitments of candidates pending availability, by `ParaId`. + **/ + pendingAvailabilityCommitments: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paraInherent: { + /** + * Whether the paras inherent was included within this block. + * + * The `Option<()>` is effectively a `bool`, but it never hits storage in the `None` variant + * due to the guarantees of FRAME's storage APIs. + * + * If this is `None` at the end of the block, we panic and render the block invalid. + **/ + included: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Scraped on chain data for extracting resolved disputes as well as backing votes. + **/ + onChainVotes: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paras: { + /** + * The actions to perform during the start of a specific session index. + **/ + actionsQueue: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Validation code stored by its hash. + * + * This storage is consistent with [`FutureCodeHash`], [`CurrentCodeHash`] and + * [`PastCodeHash`]. + **/ + codeByHash: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The number of reference on the validation code in [`CodeByHash`] storage. + **/ + codeByHashRefs: AugmentedQuery Observable, [H256]> & QueryableStorageEntry; + /** + * The validation code hash of every live para. + * + * Corresponding code can be retrieved with [`CodeByHash`]. + **/ + currentCodeHash: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The actual future code hash of a para. + * + * Corresponding code can be retrieved with [`CodeByHash`]. + **/ + futureCodeHash: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The block number at which the planned code change is expected for a para. + * The change will be applied after the first parablock for this ID included which executes + * in the context of a relay chain block with a number >= `expected_at`. + **/ + futureCodeUpgrades: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The head-data of every registered para. + **/ + heads: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * All parachains. Ordered ascending by `ParaId`. Parathreads are not included. + **/ + parachains: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current lifecycle of a all known Para IDs. + **/ + paraLifecycles: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Actual past code hash, indicated by the para id as well as the block number at which it + * became outdated. + * + * Corresponding code can be retrieved with [`CodeByHash`]. + **/ + pastCodeHash: AugmentedQuery | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable>, [ITuple<[u32, u32]>]> & QueryableStorageEntry]>; + /** + * Past code of parachains. The parachains themselves may not be registered anymore, + * but we also keep their code on-chain for the same amount of time as outdated code + * to keep it available for secondary checkers. + **/ + pastCodeMeta: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Which paras have past code that needs pruning and the relay-chain block at which the code was replaced. + * Note that this is the actual height of the included block, not the expected height at which the + * code upgrade would be applied, although they may be equal. + * This is to ensure the entire acceptance period is covered, not an offset acceptance period starting + * from the time at which the parachain perceives a code upgrade as having occurred. + * Multiple entries for a single para are permitted. Ordered ascending by block number. + **/ + pastCodePruning: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The list of all currently active PVF votes. Auxiliary to `PvfActiveVoteMap`. + **/ + pvfActiveVoteList: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * All currently active PVF pre-checking votes. + * + * Invariant: + * - There are no PVF pre-checking votes that exists in list but not in the set and vice versa. + **/ + pvfActiveVoteMap: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Upcoming paras instantiation arguments. + * + * NOTE that after PVF pre-checking is enabled the para genesis arg will have it's code set + * to empty. Instead, the code will be saved into the storage right away via `CodeByHash`. + **/ + upcomingParasGenesis: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The list of upcoming code upgrades. Each item is a pair of which para performs a code + * upgrade and at which relay-chain block it is expected at. + * + * Ordered ascending by block number. + **/ + upcomingUpgrades: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The list of parachains that are awaiting for their upgrade restriction to cooldown. + * + * Ordered ascending by block number. + **/ + upgradeCooldowns: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * This is used by the relay-chain to communicate to a parachain a go-ahead with in the upgrade procedure. + * + * This value is absent when there are no upgrades scheduled or during the time the relay chain + * performs the checks. It is set at the first relay-chain block when the corresponding parachain + * can switch its upgrade function. As soon as the parachain's block is included, the value + * gets reset to `None`. + * + * NOTE that this field is used by parachains via merkle storage proofs, therefore changing + * the format will require migration of parachains. + **/ + upgradeGoAheadSignal: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * This is used by the relay-chain to communicate that there are restrictions for performing + * an upgrade for this parachain. + * + * This may be a because the parachain waits for the upgrade cooldown to expire. Another + * potential use case is when we want to perform some maintenance (such as storage migration) + * we could restrict upgrades to make the process simpler. + * + * NOTE that this field is used by parachains via merkle storage proofs, therefore changing + * the format will require migration of parachains. + **/ + upgradeRestrictionSignal: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paraScheduler: { + /** + * One entry for each availability core. Entries are `None` if the core is not currently occupied. Can be + * temporarily `Some` if scheduled but not occupied. + * The i'th parachain belongs to the i'th core, with the remaining cores all being + * parathread-multiplexers. + * + * Bounded by the maximum of either of these two values: + * * The number of parachains and parathread multiplexers + * * The number of validators divided by `configuration.max_validators_per_core`. + **/ + availabilityCores: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * An index used to ensure that only one claim on a parathread exists in the queue or is + * currently being handled by an occupied core. + * + * Bounded by the number of parathread cores and scheduling lookahead. Reasonably, 10 * 50 = 500. + **/ + parathreadClaimIndex: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * A queue of upcoming claims and which core they should be mapped onto. + * + * The number of queued claims is bounded at the `scheduling_lookahead` + * multiplied by the number of parathread multiplexer cores. Reasonably, 10 * 50 = 500. + **/ + parathreadQueue: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Currently scheduled cores - free but up to be occupied. + * + * Bounded by the number of cores: one for each parachain and parathread multiplexer. + * + * The value contained here will not be valid after the end of a block. Runtime APIs should be used to determine scheduled cores/ + * for the upcoming block. + **/ + scheduled: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The block number where the session start occurred. Used to track how many group rotations have occurred. + * + * Note that in the context of parachains modules the session change is signaled during + * the block and enacted at the end of the block (at the finalization stage, to be exact). + * Thus for all intents and purposes the effect of the session change is observed at the + * block following the session change, block number of which we save in this storage value. + **/ + sessionStartBlock: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * All the validator groups. One for each core. Indices are into `ActiveValidators` - not the + * broader set of Polkadot validators, but instead just the subset used for parachains during + * this session. + * + * Bound: The number of cores is the sum of the numbers of parachains and parathread multiplexers. + * Reasonably, 100-1000. The dominant factor is the number of validators: safe upper bound at 10k. + **/ + validatorGroups: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + paraSessionInfo: { + /** + * Assignment keys for the current session. + * Note that this API is private due to it being prone to 'off-by-one' at session boundaries. + * When in doubt, use `Sessions` API instead. + **/ + assignmentKeysUnsafe: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The earliest session for which previous session info is stored. + **/ + earliestStoredSession: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Session information in a rolling window. + * Should have an entry in range `EarliestStoredSession..=CurrentSessionIndex`. + * Does not have any entries before the session index in the first session change notification. + **/ + sessions: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + parasShared: { + /** + * All the validators actively participating in parachain consensus. + * Indices are into the broader validator set. + **/ + activeValidatorIndices: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The parachain attestation keys of the validators actively participating in parachain consensus. + * This should be the same length as `ActiveValidatorIndices`. + **/ + activeValidatorKeys: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current session index. + **/ + currentSessionIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + phragmenElection: { + /** + * The present candidate list. A current member or runner-up can never enter this vector + * and is always implicitly assumed to be a candidate. + * + * Second element is the deposit. + * + * Invariant: Always sorted based on account id. + **/ + candidates: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The total number of vote rounds that have happened, excluding the upcoming one. + **/ + electionRounds: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The current elected members. + * + * Invariant: Always sorted based on account id. + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current reserved runners-up. + * + * Invariant: Always sorted based on rank (worse to best). Upon removal of a member, the + * last (i.e. _best_) runner-up will be replaced. + **/ + runnersUp: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Votes and locked stake of a particular voter. + * + * TWOX-NOTE: SAFE as `AccountId` is a crypto hash. + **/ + voting: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + preimage: { + /** + * The preimages stored by this pallet. + **/ + preimageFor: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The request status of a given hash. + **/ + statusFor: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + proxy: { + /** + * The announcements made by the proxy (key). + **/ + announcements: AugmentedQuery Observable, u128]>>, [AccountId32]> & QueryableStorageEntry; + /** + * 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: AugmentedQuery Observable, u128]>>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + registrar: { + /** + * The next free `ParaId`. + **/ + nextFreeParaId: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Amount held on deposit for each para and the original depositor. + * + * The given account ID is responsible for registering the code and initial head data, but may only do + * so if it isn't yet registered. (After that, it's up to governance to do so.) + **/ + paras: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Pending swap operations. + **/ + pendingSwap: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + scheduler: { + /** + * Items to be executed, indexed by the block number that they should be executed on. + **/ + agenda: AugmentedQuery Observable>>, [u32]> & QueryableStorageEntry; + /** + * Lookup from identity to the block number and index of the task. + **/ + lookup: AugmentedQuery Observable>>, [Bytes]> & QueryableStorageEntry; + /** + * Storage version of the pallet. + * + * New networks start with last version. + **/ + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + session: { + /** + * Current index of the session. + **/ + currentIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Indices of disabled validators. + * + * The vec is always kept sorted so that we can find whether a given validator is + * disabled using binary search. It gets cleared when `on_session_ending` returns + * a new set of identities. + **/ + disabledValidators: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The owner of a key. The key is the `KeyTypeId` + the encoded key. + **/ + keyOwner: AugmentedQuery | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry]>; + /** + * The next session keys for a validator. + **/ + nextKeys: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * True if the underlying economic identities or weighting behind the validators + * has changed in the queued validator set. + **/ + queuedChanged: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The queued keys for the next session. When the next session begins, these keys + * will be used to determine the validator's session keys. + **/ + queuedKeys: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The current set of validators. + **/ + validators: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + slots: { + /** + * Amounts held on deposit for each (possibly future) leased parachain. + * + * The actual amount locked on its behalf by any account at any time is the maximum of the second values + * of the items in this list whose first value is the account. + * + * The first item in the list is the amount locked for the current Lease Period. Following + * items are for the subsequent lease periods. + * + * The default value (an empty list) implies that the parachain no longer exists (or never + * existed) as far as this pallet is concerned. + * + * If a parachain doesn't exist *yet* but is scheduled to exist in the future, then it + * will be left-padded with one or more `None`s to denote the fact that nothing is held on + * deposit for the non-existent chain currently, but is held at some point in the future. + * + * It is illegal for a `None` value to trail in the list. + **/ + leases: AugmentedQuery Observable>>>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + staking: { + /** + * The active era information, it holds index and start. + * + * The active era is the era being currently rewarded. Validator set of this era must be + * equal to [`SessionInterface::validators`]. + **/ + activeEra: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Map from all locked "stash" accounts to the controller account. + **/ + bonded: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * A mapping from still-bonded eras to the first session index of that era. + * + * Must contains information for eras for the range: + * `[active_era - bounding_duration; active_era]` + **/ + bondedEras: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * The amount of currency given to reporters of a slash event which was + * canceled by extraordinary circumstances (e.g. governance). + **/ + canceledSlashPayout: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The threshold for when users can start calling `chill_other` for other validators / + * nominators. The threshold is compared to the actual number of validators / nominators + * (`CountFor*`) in the system compared to the configured max (`Max*Count`). + **/ + chillThreshold: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Counter for the related counted storage map + **/ + counterForNominators: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Counter for the related counted storage map + **/ + counterForValidators: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The current era index. + * + * This is the latest planned era, depending on how the Session pallet queues the validator + * set, it might be active or not. + **/ + currentEra: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The last planned session scheduled by the session pallet. + * + * This is basically in sync with the call to [`pallet_session::SessionManager::new_session`]. + **/ + currentPlannedSession: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The earliest era for which we have a pending, unapplied slash. + **/ + earliestUnappliedSlash: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Rewards for the last `HISTORY_DEPTH` eras. + * If reward hasn't been set or has been removed then 0 reward is returned. + **/ + erasRewardPoints: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Exposure of validator at era. + * + * This is keyed first by the era index to allow bulk deletion and then the stash account. + * + * Is it removed after `HISTORY_DEPTH` eras. + * If stakers hasn't been set or has been removed then empty exposure is returned. + **/ + erasStakers: AugmentedQuery Observable, [u32, AccountId32]> & QueryableStorageEntry; + /** + * Clipped Exposure of validator at era. + * + * This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the + * `T::MaxNominatorRewardedPerValidator` biggest stakers. + * (Note: the field `total` and `own` of the exposure remains unchanged). + * This is used to limit the i/o cost for the nominator payout. + * + * This is keyed fist by the era index to allow bulk deletion and then the stash account. + * + * Is it removed after `HISTORY_DEPTH` eras. + * If stakers hasn't been set or has been removed then empty exposure is returned. + **/ + erasStakersClipped: AugmentedQuery Observable, [u32, AccountId32]> & QueryableStorageEntry; + /** + * The session index at which the era start for the last `HISTORY_DEPTH` eras. + * + * Note: This tracks the starting session (i.e. session index when era start being active) + * for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`. + **/ + erasStartSessionIndex: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The total amount staked for the last `HISTORY_DEPTH` eras. + * If total hasn't been set or has been removed then 0 stake is returned. + **/ + erasTotalStake: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Similar to `ErasStakers`, this holds the preferences of validators. + * + * This is keyed first by the era index to allow bulk deletion and then the stash account. + * + * Is it removed after `HISTORY_DEPTH` eras. + **/ + erasValidatorPrefs: AugmentedQuery Observable, [u32, AccountId32]> & QueryableStorageEntry; + /** + * The total validator era payout for the last `HISTORY_DEPTH` eras. + * + * Eras that haven't finished yet or has been removed doesn't have reward. + **/ + erasValidatorReward: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Mode of era forcing. + **/ + forceEra: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Number of eras to keep in history. + * + * Information is kept for eras in `[current_era - history_depth; current_era]`. + * + * Must be more than the number of eras delayed by session otherwise. I.e. active era must + * always be in history. I.e. `active_era > current_era - history_depth` must be + * guaranteed. + **/ + historyDepth: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Any validators that may never be slashed or forcibly kicked. It's a Vec since they're + * easy to initialize and the performance hit is minimal (we expect no more than four + * invulnerables) and restricted to testnets. + **/ + invulnerables: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Map from all (unlocked) "controller" accounts to the info regarding the staking. + **/ + ledger: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The maximum nominator count before we stop allowing new validators to join. + * + * When this value is not set, no limits are enforced. + **/ + maxNominatorsCount: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The maximum validator count before we stop allowing new validators to join. + * + * When this value is not set, no limits are enforced. + **/ + maxValidatorsCount: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The minimum amount of commission that validators can set. + * + * If set to `0`, no limit exists. + **/ + minCommission: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Minimum number of staking participants before emergency conditions are imposed. + **/ + minimumValidatorCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The minimum active bond to become and maintain the role of a nominator. + **/ + minNominatorBond: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The minimum active bond to become and maintain the role of a validator. + **/ + minValidatorBond: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The map from nominator stash key to the set of stash keys of all validators to nominate. + **/ + nominators: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * All slashing events on nominators, mapped by era to the highest slash value of the era. + **/ + nominatorSlashInEra: AugmentedQuery Observable>, [u32, AccountId32]> & QueryableStorageEntry; + /** + * Indices of validators that have offended in the active era and whether they are currently + * disabled. + * + * This value should be a superset of disabled validators since not all offences lead to the + * validator being disabled (if there was no slash). This is needed to track the percentage of + * validators that have offended in the current era, ensuring a new era is forced if + * `OffendingValidatorsThreshold` is reached. The vec is always kept sorted so that we can find + * whether a given validator has previously offended using binary search. It gets cleared when + * the era ends. + **/ + offendingValidators: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * Where the reward payment should be made. Keyed by stash. + **/ + payee: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Slashing spans for stash accounts. + **/ + slashingSpans: AugmentedQuery Observable>, [AccountId32]> & QueryableStorageEntry; + /** + * The percentage of the slash that is distributed to reporters. + * + * The rest of the slashed value is handled by the `Slash`. + **/ + slashRewardFraction: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Records information about the maximum slash of a stash within a slashing span, + * as well as how much reward has been paid out. + **/ + spanSlash: AugmentedQuery | [AccountId32 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable, [ITuple<[AccountId32, u32]>]> & QueryableStorageEntry]>; + /** + * True if network has been upgraded to this version. + * Storage version of the pallet. + * + * This is set to v7.0.0 for new networks. + **/ + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * All unapplied slashes that are queued for later. + **/ + unappliedSlashes: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * The ideal number of staking participants. + **/ + validatorCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The map from (wannabe) validator stash key to the preferences of that validator. + **/ + validators: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * All slashing events on validators, mapped by era to the highest slash proportion + * and slash value of the era. + **/ + validatorSlashInEra: AugmentedQuery Observable>>, [u32, AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + system: { + /** + * The full account information for a particular account ID. + **/ + account: AugmentedQuery Observable, [AccountId32]> & QueryableStorageEntry; + /** + * Total length (in bytes) for all extrinsics put together, for the current block. + **/ + allExtrinsicsLen: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Map of block numbers to block hashes. + **/ + blockHash: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * The current weight for the block. + **/ + blockWeight: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Digest of the current block, also part of the block header. + **/ + digest: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The number of events in the `Events` list. + **/ + eventCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Events deposited for the current block. + * + * NOTE: This storage item is explicitly unbounded since it is never intended to be read + * from within the runtime. + **/ + events: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * 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 `(T::BlockNumber, 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: AugmentedQuery Observable>>, [H256]> & QueryableStorageEntry; + /** + * The execution phase of the block. + **/ + executionPhase: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Total extrinsics count for the current block. + **/ + extrinsicCount: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Extrinsics data for the current block (maps an extrinsic's index to its data). + **/ + extrinsicData: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened. + **/ + lastRuntimeUpgrade: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current block number being processed. Set by `execute_block`. + **/ + number: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Hash of the previous block. + **/ + parentHash: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False + * (default) if not. + **/ + upgradedToTripleRefCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not. + **/ + upgradedToU32RefCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + technicalCommittee: { + /** + * The current members of the collective. This is stored sorted (just by value). + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The prime member that helps determine the default vote behavior in case of absentations. + **/ + prime: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Proposals so far. + **/ + proposalCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Actual proposal for a given hash, if it's current. + **/ + proposalOf: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * The hashes of the active proposals. + **/ + proposals: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Votes on a given proposal, if it is ongoing. + **/ + voting: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + technicalMembership: { + /** + * The current membership, stored as an ordered Vec. + **/ + members: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The current prime member, if one exists. + **/ + prime: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + timestamp: { + /** + * Did the timestamp get updated in this block? + **/ + didUpdate: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Current time for the current block. + **/ + now: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + tips: { + /** + * Simple preimage lookup from the reason's hash to the original data. Again, has an + * insecure enumerable hash since the key is guaranteed to be the result of a secure hash. + **/ + reasons: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * TipsMap that are not yet completed. Keyed by the hash of `(reason, who)` from the value. + * This has the insecure enumerable hash function since the key itself is already + * guaranteed to be a secure hash. + **/ + tips: AugmentedQuery Observable>, [H256]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + transactionPayment: { + nextFeeMultiplier: AugmentedQuery Observable, []> & QueryableStorageEntry; + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + treasury: { + /** + * Proposal indices that have been approved but not yet awarded. + **/ + approvals: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * Number of proposals that have been made. + **/ + proposalCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Proposals that have been made. + **/ + proposals: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + ump: { + /** + * The ordered list of `ParaId`s that have a `RelayDispatchQueue` entry. + * + * Invariant: + * - The set of items from this vector should be exactly the set of the keys in + * `RelayDispatchQueues` and `RelayDispatchQueueSize`. + **/ + needsDispatch: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * This is the para that gets will get dispatched first during the next upward dispatchable queue + * execution round. + * + * Invariant: + * - If `Some(para)`, then `para` must be present in `NeedsDispatch`. + **/ + nextDispatchRoundStartWith: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The messages that exceeded max individual message weight budget. + * + * These messages stay there until manually dispatched. + **/ + overweight: AugmentedQuery Observable>>, [u64]> & QueryableStorageEntry; + /** + * The number of overweight messages ever recorded in `Overweight` (and thus the lowest free + * index). + **/ + overweightCount: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * The messages waiting to be handled by the relay-chain originating from a certain parachain. + * + * Note that some upward messages might have been already processed by the inclusion logic. E.g. + * channel management messages. + * + * The messages are processed in FIFO order. + **/ + relayDispatchQueues: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Size of the dispatch queues. Caches sizes of the queues in `RelayDispatchQueue`. + * + * First item in the tuple is the count of messages and second + * is the total length (in bytes) of the message payloads. + * + * Note that this is an auxiliary mapping: it's possible to tell the byte size and the number of + * messages only looking at `RelayDispatchQueues`. This mapping is separate to avoid the cost of + * loading the whole message queue if only the total size and count are required. + * + * Invariant: + * - The set of keys should exactly match the set of keys of `RelayDispatchQueues`. + **/ + relayDispatchQueueSize: AugmentedQuery Observable>, [u32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + vesting: { + /** + * Storage version of the pallet. + * + * New networks start with latest version, as determined by the genesis build. + **/ + storageVersion: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Information regarding the vesting of a given account. + **/ + vesting: AugmentedQuery Observable>>, [AccountId32]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + xcmPallet: { + /** + * The existing asset traps. + * + * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of + * times this pair has been trapped (usually just 1 if it exists at all). + **/ + assetTraps: AugmentedQuery Observable, [H256]> & QueryableStorageEntry; + /** + * The current migration's stage, if any. + **/ + currentMigration: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The ongoing queries. + **/ + queries: AugmentedQuery Observable>, [u64]> & QueryableStorageEntry; + /** + * The latest available query index. + **/ + queryCounter: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Default version to encode XCM when latest version of destination is unknown. If `None`, + * then the destinations whose XCM version is unknown are considered unreachable. + **/ + safeXcmVersion: AugmentedQuery Observable>, []> & QueryableStorageEntry; + /** + * The Latest versions that we know various locations support. + **/ + supportedVersion: AugmentedQuery Observable>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry; + /** + * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and + * the `u32` counter is the number of times that a send to the destination has been attempted, + * which is used as a prioritization. + **/ + versionDiscoveryQueue: AugmentedQuery Observable>>, []> & QueryableStorageEntry; + /** + * All locations that we have requested version notifications from. + **/ + versionNotifiers: AugmentedQuery Observable>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry; + /** + * The target locations that are subscribed to our version changes, as well as the most recent + * of our versions we informed them of. + **/ + versionNotifyTargets: AugmentedQuery Observable>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry; + /** + * Generic query + **/ + [key: string]: QueryableStorageEntry; + }; + } // AugmentedQueries +} // declare module diff --git a/packages/api-augment/src/polkadot/tx.ts b/packages/api-augment/src/polkadot/tx.ts new file mode 100644 index 0000000000..0df8bb493c --- /dev/null +++ b/packages/api-augment/src/polkadot/tx.ts @@ -0,0 +1,3708 @@ +// Auto-generated via `yarn polkadot-types-from-chain`, do not edit +/* eslint-disable */ + +import type { ApiTypes } from '@polkadot/api-base/types'; +import type { Data } from '@polkadot/types'; +import type { Bytes, Compact, Option, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; +import type { AnyNumber, ITuple } from '@polkadot/types-codec/types'; +import type { EthereumAddress } from '@polkadot/types/interfaces/eth'; +import type { AccountId32, Call, H256, MultiAddress, Perbill, Percent } from '@polkadot/types/interfaces/runtime'; +import type { FrameSupportScheduleMaybeHashed, PalletDemocracyConviction, PalletDemocracyVoteAccountVote, PalletElectionProviderMultiPhaseRawSolution, PalletElectionProviderMultiPhaseSolutionOrSnapshotSize, PalletElectionsPhragmenRenouncing, PalletIdentityBitFlags, PalletIdentityIdentityInfo, PalletIdentityJudgement, PalletImOnlineHeartbeat, PalletImOnlineSr25519AppSr25519Signature, PalletMultisigTimepoint, PalletStakingRewardDestination, PalletStakingValidatorPrefs, PalletVestingVestingInfo, PolkadotParachainPrimitivesHrmpChannelId, PolkadotPrimitivesV0ValidatorAppSignature, PolkadotPrimitivesV1InherentData, PolkadotPrimitivesV1PvfCheckStatement, PolkadotRuntimeCommonClaimsEcdsaSignature, PolkadotRuntimeCommonClaimsStatementKind, PolkadotRuntimeOriginCaller, PolkadotRuntimeProxyType, PolkadotRuntimeSessionKeys, SpConsensusBabeDigestsNextConfigDescriptor, SpConsensusSlotsEquivocationProof, SpFinalityGrandpaEquivocationProof, SpNposElectionsSupport, SpRuntimeHeader, SpRuntimeMultiSignature, SpRuntimeMultiSigner, SpSessionMembershipProof, XcmV1MultiLocation, XcmV2WeightLimit, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from '@polkadot/types/lookup'; + +declare module '@polkadot/api-base/types/submittable' { + export interface AugmentedSubmittables { + auctions: { + /** + * Make a new bid from an account (including a parachain account) for deploying a new + * parachain. + * + * Multiple simultaneous bids from the same bidder are allowed only as long as all active + * bids overlap each other (i.e. are mutually exclusive). Bids cannot be redacted. + * + * - `sub` is the sub-bidder ID, allowing for multiple competing bids to be made by (and + * funded by) the same account. + * - `auction_index` is the index of the auction to bid on. Should just be the present + * value of `AuctionCounter`. + * - `first_slot` is the first lease period index of the range to bid on. This is the + * absolute lease period index value, not an auction-specific offset. + * - `last_slot` is the last lease period index of the range to bid on. This is the + * absolute lease period index value, not an auction-specific offset. + * - `amount` is the amount to bid to be held as deposit for the parachain should the + * bid win. This amount is held throughout the range. + **/ + bid: AugmentedSubmittable<(para: Compact | AnyNumber | Uint8Array, auctionIndex: Compact | AnyNumber | Uint8Array, firstSlot: Compact | AnyNumber | Uint8Array, lastSlot: Compact | AnyNumber | Uint8Array, amount: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact, Compact, Compact, Compact]>; + /** + * Cancel an in-progress auction. + * + * Can only be called by Root origin. + **/ + cancelAuction: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Create a new auction. + * + * This can only happen when there isn't already an auction in progress and may only be + * called by the root origin. Accepts the `duration` of this auction and the + * `lease_period_index` of the initial lease period of the four that are to be auctioned. + **/ + newAuction: AugmentedSubmittable<(duration: Compact | AnyNumber | Uint8Array, leasePeriodIndex: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + authorship: { + /** + * Provide a set of uncles. + **/ + setUncles: AugmentedSubmittable<(newUncles: Vec | (SpRuntimeHeader | { parentHash?: any; number?: any; stateRoot?: any; extrinsicsRoot?: any; digest?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + babe: { + /** + * Plan an epoch config change. The epoch config change is recorded and will be enacted on + * the next call to `enact_epoch_change`. The config will be activated one epoch after. + * Multiple calls to this method will replace any existing planned config change that had + * not been enacted yet. + **/ + planConfigChange: AugmentedSubmittable<(config: SpConsensusBabeDigestsNextConfigDescriptor | { V1: any } | string | Uint8Array) => SubmittableExtrinsic, [SpConsensusBabeDigestsNextConfigDescriptor]>; + /** + * Report authority equivocation/misbehavior. This method will verify + * the equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence will + * be reported. + **/ + reportEquivocation: AugmentedSubmittable<(equivocationProof: SpConsensusSlotsEquivocationProof | { offender?: any; slot?: any; firstHeader?: any; secondHeader?: any } | string | Uint8Array, keyOwnerProof: SpSessionMembershipProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic, [SpConsensusSlotsEquivocationProof, SpSessionMembershipProof]>; + /** + * Report authority equivocation/misbehavior. This method will verify + * the equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence will + * be reported. + * This extrinsic must be called unsigned and it is expected that only + * block authors will call it (validated in `ValidateUnsigned`), as such + * if the block author is defined it will be defined as the equivocation + * reporter. + **/ + reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: SpConsensusSlotsEquivocationProof | { offender?: any; slot?: any; firstHeader?: any; secondHeader?: any } | string | Uint8Array, keyOwnerProof: SpSessionMembershipProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic, [SpConsensusSlotsEquivocationProof, SpSessionMembershipProof]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + bagsList: { + /** + * Move the caller's Id directly in front of `lighter`. + * + * The dispatch origin for this call must be _Signed_ and can only be called by the Id of + * the account going in front of `lighter`. + * + * Only works if + * - both nodes are within the same bag, + * - and `origin` has a greater `VoteWeight` than `lighter`. + **/ + putInFrontOf: AugmentedSubmittable<(lighter: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Declare that some `dislocated` account has, through rewards or penalties, sufficiently + * changed its weight that it should properly fall into a different bag than its current + * one. + * + * Anyone can call this function about any potentially dislocated account. + * + * Will never return an error; if `dislocated` does not exist or doesn't need a rebag, then + * it is a noop and fees are still collected from `origin`. + **/ + rebag: AugmentedSubmittable<(dislocated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + balances: { + /** + * Exactly as `transfer`, except the origin must be root and the source account may be + * specified. + * # + * - Same as transfer, but additional read and write because the source account is not + * assumed to be in the overlay. + * # + **/ + forceTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, MultiAddress, Compact]>; + /** + * Unreserve some balance from a user by force. + * + * Can only be called by ROOT. + **/ + forceUnreserve: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, u128]>; + /** + * 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 reset the account nonce (`frame_system::AccountNonce`). + * + * The dispatch origin for this call is `root`. + **/ + setBalance: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact | AnyNumber | Uint8Array, newReserved: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact, Compact]>; + /** + * 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. + * + * # + * - Dependent on arguments but not critical, given proper implementations for input config + * types. See related functions below. + * - It contains a limited number of reads and writes internally and no complex + * computation. + * + * Related functions: + * + * - `ensure_can_withdraw` is always called internally but has a bounded complexity. + * - Transferring balances to accounts that did not exist before will cause + * `T::OnNewAccount::on_new_account` to be called. + * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`. + * - `transfer_keep_alive` works the same way as `transfer`, but has an additional check + * that the transfer will not kill the origin account. + * --------------------------------- + * - Origin account is already in memory, so no DB operations for them. + * # + **/ + transfer: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact]>; + /** + * Transfer the entire transferable balance from the caller account. + * + * NOTE: This function only attempts to transfer _transferable_ balances. This means that + * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be + * transferred by this function. To ensure that this function results in a killed account, + * you might need to prepare the account by removing any reference counters, storage + * deposits, etc... + * + * The dispatch origin of this call must be Signed. + * + * - `dest`: The recipient of the transfer. + * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all + * of the funds the account has, causing the sender account to be killed (false), or + * transfer everything except at least the existential deposit, which will guarantee to + * keep the sender account alive (true). # + * - O(1). Just like transfer, but reading the user's transferable balance first. + * # + **/ + transferAll: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic, [MultiAddress, bool]>; + /** + * 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. + * + * [`transfer`]: struct.Pallet.html#method.transfer + **/ + transferKeepAlive: AugmentedSubmittable<(dest: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + bounties: { + /** + * Accept the curator role for a bounty. + * A deposit will be reserved from curator and refund upon successful payout. + * + * May only be called from the curator. + * + * # + * - O(1). + * # + **/ + acceptCurator: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Approve a bounty proposal. At a later time, the bounty will be funded and become active + * and the original deposit will be returned. + * + * May only be called from `T::ApproveOrigin`. + * + * # + * - O(1). + * # + **/ + approveBounty: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Award bounty to a beneficiary account. The beneficiary will be able to claim the funds + * after a delay. + * + * The dispatch origin for this call must be the curator of this bounty. + * + * - `bounty_id`: Bounty ID to award. + * - `beneficiary`: The beneficiary account whom will receive the payout. + * + * # + * - O(1). + * # + **/ + awardBounty: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array, beneficiary: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [Compact, MultiAddress]>; + /** + * Claim the payout from an awarded bounty after payout delay. + * + * The dispatch origin for this call must be the beneficiary of this bounty. + * + * - `bounty_id`: Bounty ID to claim. + * + * # + * - O(1). + * # + **/ + claimBounty: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Cancel a proposed or active bounty. All the funds will be sent to treasury and + * the curator deposit will be unreserved if possible. + * + * Only `T::RejectOrigin` is able to cancel a bounty. + * + * - `bounty_id`: Bounty ID to cancel. + * + * # + * - O(1). + * # + **/ + closeBounty: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Extend the expiry time of an active bounty. + * + * The dispatch origin for this call must be the curator of this bounty. + * + * - `bounty_id`: Bounty ID to extend. + * - `remark`: additional information. + * + * # + * - O(1). + * # + **/ + extendBountyExpiry: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array, remark: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Compact, Bytes]>; + /** + * Propose a new bounty. + * + * The dispatch origin for this call must be _Signed_. + * + * Payment: `TipReportDepositBase` will be reserved from the origin account, as well as + * `DataDepositPerByte` for each byte in `reason`. It will be unreserved upon approval, + * or slashed when rejected. + * + * - `curator`: The curator account whom will manage this bounty. + * - `fee`: The curator fee. + * - `value`: The total payment amount of this bounty, curator fee included. + * - `description`: The description of this bounty. + **/ + proposeBounty: AugmentedSubmittable<(value: Compact | AnyNumber | Uint8Array, description: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Compact, Bytes]>; + /** + * Assign a curator to a funded bounty. + * + * May only be called from `T::ApproveOrigin`. + * + * # + * - O(1). + * # + **/ + proposeCurator: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array, curator: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, fee: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, MultiAddress, Compact]>; + /** + * Unassign curator from a bounty. + * + * This function can only be called by the `RejectOrigin` a signed origin. + * + * If this function is called by the `RejectOrigin`, we assume that the curator is + * malicious or inactive. As a result, we will slash the curator when possible. + * + * If the origin is the curator, we take this as a sign they are unable to do their job and + * they willingly give up. We could slash them, but for now we allow them to recover their + * deposit and exit without issue. (We may want to change this if it is abused.) + * + * Finally, the origin can be anyone if and only if the curator is "inactive". This allows + * anyone in the community to call out that a curator is not doing their due diligence, and + * we should pick a new curator. In this case the curator should also be slashed. + * + * # + * - O(1). + * # + **/ + unassignCurator: AugmentedSubmittable<(bountyId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + claims: { + /** + * Attest to a statement, needed to finalize the claims process. + * + * WARNING: Insecure unless your chain includes `PrevalidateAttests` as a `SignedExtension`. + * + * Unsigned Validation: + * A call to attest is deemed valid if the sender has a `Preclaim` registered + * and provides a `statement` which is expected for the account. + * + * Parameters: + * - `statement`: The identity of the statement which is being attested to in the signature. + * + * + * The weight of this call is invariant over the input parameters. + * Weight includes logic to do pre-validation on `attest` call. + * + * Total Complexity: O(1) + * + **/ + attest: AugmentedSubmittable<(statement: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Make a claim to collect your DOTs. + * + * The dispatch origin for this call must be _None_. + * + * Unsigned Validation: + * A call to claim is deemed valid if the signature provided matches + * the expected signed message of: + * + * > Ethereum Signed Message: + * > (configured prefix string)(address) + * + * and `address` matches the `dest` account. + * + * Parameters: + * - `dest`: The destination account to payout the claim. + * - `ethereum_signature`: The signature of an ethereum signed message + * matching the format described above. + * + * + * The weight of this call is invariant over the input parameters. + * Weight includes logic to validate unsigned `claim` call. + * + * Total Complexity: O(1) + * + **/ + claim: AugmentedSubmittable<(dest: AccountId32 | string | Uint8Array, ethereumSignature: PolkadotRuntimeCommonClaimsEcdsaSignature | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, PolkadotRuntimeCommonClaimsEcdsaSignature]>; + /** + * Make a claim to collect your DOTs by signing a statement. + * + * The dispatch origin for this call must be _None_. + * + * Unsigned Validation: + * A call to `claim_attest` is deemed valid if the signature provided matches + * the expected signed message of: + * + * > Ethereum Signed Message: + * > (configured prefix string)(address)(statement) + * + * and `address` matches the `dest` account; the `statement` must match that which is + * expected according to your purchase arrangement. + * + * Parameters: + * - `dest`: The destination account to payout the claim. + * - `ethereum_signature`: The signature of an ethereum signed message + * matching the format described above. + * - `statement`: The identity of the statement which is being attested to in the signature. + * + * + * The weight of this call is invariant over the input parameters. + * Weight includes logic to validate unsigned `claim_attest` call. + * + * Total Complexity: O(1) + * + **/ + claimAttest: AugmentedSubmittable<(dest: AccountId32 | string | Uint8Array, ethereumSignature: PolkadotRuntimeCommonClaimsEcdsaSignature | string | Uint8Array, statement: Bytes | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, PolkadotRuntimeCommonClaimsEcdsaSignature, Bytes]>; + /** + * Mint a new claim to collect DOTs. + * + * The dispatch origin for this call must be _Root_. + * + * Parameters: + * - `who`: The Ethereum address allowed to collect this claim. + * - `value`: The number of DOTs that will be claimed. + * - `vesting_schedule`: An optional vesting schedule for these DOTs. + * + * + * The weight of this call is invariant over the input parameters. + * We assume worst case that both vesting and statement is being inserted. + * + * Total Complexity: O(1) + * + **/ + mintClaim: AugmentedSubmittable<(who: EthereumAddress | string | Uint8Array, value: u128 | AnyNumber | Uint8Array, vestingSchedule: Option> | null | object | string | Uint8Array, statement: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [EthereumAddress, u128, Option>, Option]>; + moveClaim: AugmentedSubmittable<(old: EthereumAddress | string | Uint8Array, updated: EthereumAddress | string | Uint8Array, maybePreclaim: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [EthereumAddress, EthereumAddress, Option]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + configuration: { + /** + * Set the availability period for parachains. + **/ + setChainAvailabilityPeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the acceptance period for an included candidate. + **/ + setCodeRetentionPeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the dispute conclusion by time out period. + **/ + setDisputeConclusionByTimeOutPeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the maximum number of dispute spam slots. + **/ + setDisputeMaxSpamSlots: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the dispute period, in number of sessions to keep for disputes. + **/ + setDisputePeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the dispute post conclusion acceptance period. + **/ + setDisputePostConclusionAcceptancePeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the parachain validator-group rotation frequency + **/ + setGroupRotationFrequency: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of messages allowed in an HRMP channel at once. + **/ + setHrmpChannelMaxCapacity: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum size of a message that could ever be put into an HRMP channel. + **/ + setHrmpChannelMaxMessageSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum total size of messages in bytes allowed in an HRMP channel at once. + **/ + setHrmpChannelMaxTotalSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of outbound HRMP messages can be sent by a candidate. + **/ + setHrmpMaxMessageNumPerCandidate: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of inbound HRMP channels a parachain is allowed to accept. + **/ + setHrmpMaxParachainInboundChannels: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of outbound HRMP channels a parachain is allowed to open. + **/ + setHrmpMaxParachainOutboundChannels: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of inbound HRMP channels a parathread is allowed to accept. + **/ + setHrmpMaxParathreadInboundChannels: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of outbound HRMP channels a parathread is allowed to open. + **/ + setHrmpMaxParathreadOutboundChannels: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the number of sessions after which an HRMP open channel request expires. + **/ + setHrmpOpenRequestTtl: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the amount of funds that the recipient should provide for accepting opening an HRMP + * channel. + **/ + setHrmpRecipientDeposit: AugmentedSubmittable<(updated: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u128]>; + /** + * Sets the amount of funds that the sender should provide for opening an HRMP channel. + **/ + setHrmpSenderDeposit: AugmentedSubmittable<(updated: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u128]>; + /** + * Set the max validation code size for incoming upgrades. + **/ + setMaxCodeSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the critical downward message size. + **/ + setMaxDownwardMessageSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the max head data size for paras. + **/ + setMaxHeadDataSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the max POV block size for incoming upgrades. + **/ + setMaxPovSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum number of messages that a candidate can contain. + **/ + setMaxUpwardMessageNumPerCandidate: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum size of an upward message that can be sent by a candidate. + **/ + setMaxUpwardMessageSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum items that can present in a upward dispatch queue at once. + **/ + setMaxUpwardQueueCount: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum total size of items that can present in a upward dispatch queue at once. + **/ + setMaxUpwardQueueSize: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the maximum number of validators to use in parachain consensus. + **/ + setMaxValidators: AugmentedSubmittable<(updated: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Option]>; + /** + * Set the maximum number of validators to assign to any core. + **/ + setMaxValidatorsPerCore: AugmentedSubmittable<(updated: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Option]>; + /** + * Sets the minimum delay between announcing the upgrade block for a parachain until the + * upgrade taking place. + **/ + setMinimumValidationUpgradeDelay: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the total number of delay tranches. + **/ + setNDelayTranches: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the number of validators needed to approve a block. + **/ + setNeededApprovals: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the no show slots, in number of number of consensus slots. + * Must be at least 1. + **/ + setNoShowSlots: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the number of parathread execution cores. + **/ + setParathreadCores: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the number of retries for a particular parathread. + **/ + setParathreadRetries: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Enable or disable PVF pre-checking. Consult the field documentation prior executing. + **/ + setPvfCheckingEnabled: AugmentedSubmittable<(updated: bool | boolean | Uint8Array) => SubmittableExtrinsic, [bool]>; + /** + * Set the number of session changes after which a PVF pre-checking voting is rejected. + **/ + setPvfVotingTtl: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the number of samples to do of the `RelayVRFModulo` approval assignment criterion. + **/ + setRelayVrfModuloSamples: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the scheduling lookahead, in expected number of blocks at peak throughput. + **/ + setSchedulingLookahead: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the availability period for parathreads. + **/ + setThreadAvailabilityPeriod: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Sets the maximum amount of weight any individual upward message may consume. + **/ + setUmpMaxIndividualWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64]>; + /** + * Sets the soft limit for the phase of dispatching dispatchable upward messages. + **/ + setUmpServiceTotalWeight: AugmentedSubmittable<(updated: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64]>; + /** + * Set the validation upgrade delay. + **/ + setValidationUpgradeDelay: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the validation upgrade frequency. + **/ + setValidationUpgradeFrequency: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Set the zeroth delay tranche width. + **/ + setZerothDelayTrancheWidth: AugmentedSubmittable<(updated: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + council: { + /** + * Close a vote that is either approved, disapproved or whose voting period has ended. + * + * May be called by any signed account in order to finish voting and close the proposal. + * + * If called before the end of the voting period it will only close the vote if it is + * has enough votes to be approved or disapproved. + * + * If called after the end of the voting period abstentions are counted as rejections + * unless there is a prime member set and the prime member cast an approval. + * + * If the close operation completes successfully with disapproval, the transaction fee will + * be waived. Otherwise execution of the approved operation will be charged to the caller. + * + * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed + * proposal. + * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via + * `storage::read` so it is `size_of::() == 4` larger than the pure length. + * + * # + * ## Weight + * - `O(B + M + P1 + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - `P1` is the complexity of `proposal` preimage. + * - `P2` is proposal-count (code-bounded) + * - DB: + * - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`) + * - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec + * `O(P2)`) + * - any mutations done while executing `proposal` (`P1`) + * - up to 3 events + * # + **/ + close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, proposalWeightBound: Compact | AnyNumber | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact, Compact, Compact]>; + /** + * Disapprove a proposal, close, and remove it from the system, regardless of its current + * state. + * + * Must be called by the Root origin. + * + * Parameters: + * * `proposal_hash`: The hash of the proposal that should be disapproved. + * + * # + * Complexity: O(P) where P is the number of max proposals + * DB Weight: + * * Reads: Proposals + * * Writes: Voting, Proposals, ProposalOf + * # + **/ + disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Dispatch a proposal from a member using the `Member` origin. + * + * Origin must be a member of the collective. + * + * # + * ## Weight + * - `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching + * `proposal` + * - DB: 1 read (codec `O(M)`) + DB access of `proposal` + * - 1 event + * # + **/ + execute: AugmentedSubmittable<(proposal: Call | { callIndex?: any; args?: any } | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Call, Compact]>; + /** + * Add a new proposal to either be voted on or executed directly. + * + * Requires the sender to be member. + * + * `threshold` determines whether `proposal` is executed directly (`threshold < 2`) + * or put up for voting. + * + * # + * ## Weight + * - `O(B + M + P1)` or `O(B + M + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - branching is influenced by `threshold` where: + * - `P1` is proposal execution complexity (`threshold < 2`) + * - `P2` is proposals-count (code-bounded) (`threshold >= 2`) + * - DB: + * - 1 storage read `is_member` (codec `O(M)`) + * - 1 storage read `ProposalOf::contains_key` (codec `O(1)`) + * - DB accesses influenced by `threshold`: + * - EITHER storage accesses done by `proposal` (`threshold < 2`) + * - OR proposal insertion (`threshold <= 2`) + * - 1 storage mutation `Proposals` (codec `O(P2)`) + * - 1 storage mutation `ProposalCount` (codec `O(1)`) + * - 1 storage write `ProposalOf` (codec `O(B)`) + * - 1 storage write `Voting` (codec `O(M)`) + * - 1 event + * # + **/ + propose: AugmentedSubmittable<(threshold: Compact | AnyNumber | Uint8Array, proposal: Call | { callIndex?: any; args?: any } | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Call, Compact]>; + /** + * Set the collective's membership. + * + * - `new_members`: The new member list. Be nice to the chain and provide it sorted. + * - `prime`: The prime member whose vote sets the default. + * - `old_count`: The upper bound for the previous number of members in storage. Used for + * weight estimation. + * + * Requires root origin. + * + * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but + * the weight estimations rely on it to estimate dispatchable weight. + * + * # WARNING: + * + * The `pallet-collective` can also be managed by logic outside of the pallet through the + * implementation of the trait [`ChangeMembers`]. + * Any call to `set_members` must be careful that the member set doesn't get out of sync + * with other logic managing the member set. + * + * # + * ## Weight + * - `O(MP + N)` where: + * - `M` old-members-count (code- and governance-bounded) + * - `N` new-members-count (code- and governance-bounded) + * - `P` proposals-count (code-bounded) + * - DB: + * - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the + * members + * - 1 storage read (codec `O(P)`) for reading the proposals + * - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal + * - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one + * # + **/ + setMembers: AugmentedSubmittable<(newMembers: Vec | (AccountId32 | string | Uint8Array)[], prime: Option | null | object | string | Uint8Array, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, Option, u32]>; + /** + * Add an aye or nay vote for the sender to the given proposal. + * + * Requires the sender to be a member. + * + * Transaction fees will be waived if the member is voting on any particular proposal + * for the first time and the call is successful. Subsequent vote changes will charge a + * fee. + * # + * ## Weight + * - `O(M)` where `M` is members-count (code- and governance-bounded) + * - DB: + * - 1 storage read `Members` (codec `O(M)`) + * - 1 storage mutation `Voting` (codec `O(M)`) + * - 1 event + * # + **/ + vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic, [H256, Compact, bool]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + crowdloan: { + /** + * Add an optional memo to an existing crowdloan contribution. + * + * Origin must be Signed, and the user must have contributed to the crowdloan. + **/ + addMemo: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array, memo: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + /** + * Contribute to a crowd sale. This will transfer some balance over to fund a parachain + * slot. It will be withdrawable when the crowdloan has ended and the funds are unused. + **/ + contribute: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, value: Compact | AnyNumber | Uint8Array, signature: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Compact, Compact, Option]>; + /** + * Contribute your entire balance to a crowd sale. This will transfer the entire balance of a user over to fund a parachain + * slot. It will be withdrawable when the crowdloan has ended and the funds are unused. + **/ + contributeAll: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, signature: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Compact, Option]>; + /** + * Create a new crowdloaning campaign for a parachain slot with the given lease period range. + * + * This applies a lock to your parachain configuration, ensuring that it cannot be changed + * by the parachain manager. + **/ + create: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, cap: Compact | AnyNumber | Uint8Array, firstPeriod: Compact | AnyNumber | Uint8Array, lastPeriod: Compact | AnyNumber | Uint8Array, end: Compact | AnyNumber | Uint8Array, verifier: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Compact, Compact, Compact, Compact, Compact, Option]>; + /** + * Remove a fund after the retirement period has ended and all funds have been returned. + **/ + dissolve: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Edit the configuration for an in-progress crowdloan. + * + * Can only be called by Root origin. + **/ + edit: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, cap: Compact | AnyNumber | Uint8Array, firstPeriod: Compact | AnyNumber | Uint8Array, lastPeriod: Compact | AnyNumber | Uint8Array, end: Compact | AnyNumber | Uint8Array, verifier: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Compact, Compact, Compact, Compact, Compact, Option]>; + /** + * Poke the fund into `NewRaise` + * + * Origin must be Signed, and the fund has non-zero raise. + **/ + poke: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Automatically refund contributors of an ended crowdloan. + * Due to weight restrictions, this function may need to be called multiple + * times to fully refund all users. We will refund `RemoveKeysLimit` users at a time. + * + * Origin must be signed, but can come from anyone. + **/ + refund: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Withdraw full balance of a specific contributor. + * + * Origin must be signed, but can come from anyone. + * + * The fund must be either in, or ready for, retirement. For a fund to be *in* retirement, then the retirement + * flag must be set. For a fund to be ready for retirement, then: + * - it must not already be in retirement; + * - the amount of raised funds must be bigger than the _free_ balance of the account; + * - and either: + * - the block number must be at least `end`; or + * - the current lease period must be greater than the fund's `last_period`. + * + * In this case, the fund's retirement flag is set and its `end` is reset to the current block + * number. + * + * - `who`: The account whose contribution should be withdrawn. + * - `index`: The parachain to whose crowdloan the contribution was made. + **/ + withdraw: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + democracy: { + /** + * 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: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, maybeRefIndex: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [H256, Option]>; + /** + * 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()` + **/ + cancelProposal: AugmentedSubmittable<(propIndex: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Cancel a proposal queued for enactment. + * + * The dispatch origin of this call must be _Root_. + * + * - `which`: The index of the referendum to cancel. + * + * Weight: `O(D)` where `D` is the items in the dispatch queue. Weighted as `D = 10`. + **/ + cancelQueued: AugmentedSubmittable<(which: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Remove a referendum. + * + * The dispatch origin of this call must be _Root_. + * + * - `ref_index`: The index of the referendum to cancel. + * + * # Weight: `O(1)`. + **/ + cancelReferendum: AugmentedSubmittable<(refIndex: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Clears all public proposals. + * + * The dispatch origin of this call must be _Root_. + * + * Weight: `O(1)`. + **/ + clearPublicProposals: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * 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: AugmentedSubmittable<(to: AccountId32 | string | Uint8Array, conviction: PalletDemocracyConviction | 'None' | 'Locked1x' | 'Locked2x' | 'Locked3x' | 'Locked4x' | 'Locked5x' | 'Locked6x' | number | Uint8Array, balance: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, PalletDemocracyConviction, u128]>; + /** + * 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)`. + **/ + emergencyCancel: AugmentedSubmittable<(refIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Enact a proposal from a referendum. For now we just make the weight be the maximum. + **/ + enactProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, u32]>; + /** + * 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. + * + * Weight: `O(V)` with V number of vetoers in the blacklist of proposal. + * Decoding vec of length V. Charged as maximum + **/ + externalPropose: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * 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)` + **/ + externalProposeDefault: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * 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)` + **/ + externalProposeMajority: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * 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 + * `FastTrackVotingPeriod` if too low. + * - `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)` + **/ + fastTrack: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, votingPeriod: u32 | AnyNumber | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, u32, u32]>; + /** + * Register the preimage for an upcoming proposal. This requires the proposal to be + * in the dispatch queue. No deposit is needed. When this call is successful, i.e. + * the preimage has not been uploaded before and matches some imminent proposal, + * no fee is paid. + * + * The dispatch origin of this call must be _Signed_. + * + * - `encoded_proposal`: The preimage of a proposal. + * + * Emits `PreimageNoted`. + * + * Weight: `O(E)` with E size of `encoded_proposal` (protected by a required deposit). + **/ + noteImminentPreimage: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Same as `note_imminent_preimage` but origin is `OperationalPreimageOrigin`. + **/ + noteImminentPreimageOperational: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Register the preimage for an upcoming proposal. This doesn't require the proposal to be + * in the dispatch queue but does require a deposit, returned once enacted. + * + * The dispatch origin of this call must be _Signed_. + * + * - `encoded_proposal`: The preimage of a proposal. + * + * Emits `PreimageNoted`. + * + * Weight: `O(E)` with E size of `encoded_proposal` (protected by a required deposit). + **/ + notePreimage: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Same as `note_preimage` but origin is `OperationalPreimageOrigin`. + **/ + notePreimageOperational: AugmentedSubmittable<(encodedProposal: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * 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`. + * + * Weight: `O(p)` + **/ + propose: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact]>; + /** + * Remove an expired proposal preimage and collect the deposit. + * + * The dispatch origin of this call must be _Signed_. + * + * - `proposal_hash`: The preimage hash of a proposal. + * - `proposal_length_upper_bound`: an upper bound on length of the proposal. Extrinsic is + * weighted according to this value with no refund. + * + * This will only work after `VotingPeriod` blocks from the time that the preimage was + * noted, if it's the same account doing it. If it's a different account, then it'll only + * work an additional `EnactmentPeriod` later. + * + * Emits `PreimageReaped`. + * + * Weight: `O(D)` where D is length of proposal. + **/ + reapPreimage: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, proposalLenUpperBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact]>; + /** + * 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. + **/ + removeOtherVote: AugmentedSubmittable<(target: AccountId32 | string | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * 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. + **/ + removeVote: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * 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. + * - `seconds_upper_bound`: an upper bound on the current number of seconds on this + * proposal. Extrinsic is weighted according to this value with no refund. + * + * Weight: `O(S)` where S is the number of seconds a proposal already has. + **/ + second: AugmentedSubmittable<(proposal: Compact | AnyNumber | Uint8Array, secondsUpperBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * 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: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * 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: AugmentedSubmittable<(target: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * 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` + **/ + vetoExternal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * 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. + * + * Weight: `O(R)` where R is the number of referendums the voter has voted on. + **/ + vote: AugmentedSubmittable<(refIndex: Compact | AnyNumber | Uint8Array, vote: PalletDemocracyVoteAccountVote | { Standard: any } | { Split: any } | string | Uint8Array) => SubmittableExtrinsic, [Compact, PalletDemocracyVoteAccountVote]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + dmp: { + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + electionProviderMultiPhase: { + /** + * Set a solution in the queue, to be handed out to the client of this pallet in the next + * call to `ElectionProvider::elect`. + * + * This can only be set by `T::ForceOrigin`, and only when the phase is `Emergency`. + * + * The solution is not checked for any feasibility and is assumed to be trustworthy, as any + * feasibility check itself can in principle cause the election process to fail (due to + * memory/weight constrains). + **/ + setEmergencyElectionResult: AugmentedSubmittable<(supports: Vec> | ([AccountId32 | string | Uint8Array, SpNposElectionsSupport | { total?: any; voters?: any } | string | Uint8Array])[]) => SubmittableExtrinsic, [Vec>]>; + /** + * Set a new value for `MinimumUntrustedScore`. + * + * Dispatch origin must be aligned with `T::ForceOrigin`. + * + * This check can be turned off by setting the value to `None`. + **/ + setMinimumUntrustedScore: AugmentedSubmittable<(maybeNextScore: Option> | null | object | string | Uint8Array) => SubmittableExtrinsic, [Option>]>; + /** + * Submit a solution for the signed phase. + * + * The dispatch origin fo this call must be __signed__. + * + * The solution is potentially queued, based on the claimed score and processed at the end + * of the signed phase. + * + * A deposit is reserved and recorded for the solution. Based on the outcome, the solution + * might be rewarded, slashed, or get all or a part of the deposit back. + * + * # + * Queue size must be provided as witness data. + * # + **/ + submit: AugmentedSubmittable<(rawSolution: PalletElectionProviderMultiPhaseRawSolution | { solution?: any; score?: any; round?: any } | string | Uint8Array, numSignedSubmissions: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [PalletElectionProviderMultiPhaseRawSolution, u32]>; + /** + * Submit a solution for the unsigned phase. + * + * The dispatch origin fo this call must be __none__. + * + * This submission is checked on the fly. Moreover, this unsigned solution is only + * validated when submitted to the pool from the **local** node. Effectively, this means + * that only active validators can submit this transaction when authoring a block (similar + * to an inherent). + * + * To prevent any incorrect solution (and thus wasted time/weight), this transaction will + * panic if the solution submitted by the validator is invalid in any way, effectively + * putting their authoring reward at risk. + * + * No deposit or reward is associated with this submission. + **/ + submitUnsigned: AugmentedSubmittable<(rawSolution: PalletElectionProviderMultiPhaseRawSolution | { solution?: any; score?: any; round?: any } | string | Uint8Array, witness: PalletElectionProviderMultiPhaseSolutionOrSnapshotSize | { voters?: any; targets?: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletElectionProviderMultiPhaseRawSolution, PalletElectionProviderMultiPhaseSolutionOrSnapshotSize]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + grandpa: { + /** + * Note that the current authority set of the GRANDPA finality gadget has + * stalled. This will trigger a forced authority set change at the beginning + * of the next session, to be enacted `delay` blocks after that. The delay + * should be high enough to safely assume that the block signalling the + * forced change will not be re-orged (e.g. 1000 blocks). The GRANDPA voters + * will start the new authority set using the given finalized block as base. + * Only callable by root. + **/ + noteStalled: AugmentedSubmittable<(delay: u32 | AnyNumber | Uint8Array, bestFinalizedBlockNumber: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + **/ + reportEquivocation: AugmentedSubmittable<(equivocationProof: SpFinalityGrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: SpSessionMembershipProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic, [SpFinalityGrandpaEquivocationProof, SpSessionMembershipProof]>; + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + * + * This extrinsic must be called unsigned and it is expected that only + * block authors will call it (validated in `ValidateUnsigned`), as such + * if the block author is defined it will be defined as the equivocation + * reporter. + **/ + reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: SpFinalityGrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: SpSessionMembershipProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic, [SpFinalityGrandpaEquivocationProof, SpSessionMembershipProof]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + hrmp: { + /** + * This extrinsic triggers the cleanup of all the HRMP storage items that + * a para may have. Normally this happens once per session, but this allows + * you to trigger the cleanup immediately for a specific parachain. + * + * Origin must be Root. + **/ + forceCleanHrmp: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Force process HRMP close channel requests. + * + * If there are pending HRMP close channel requests, you can use this + * function process all of those requests immediately. + **/ + forceProcessHrmpClose: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Force process HRMP open channel requests. + * + * If there are pending HRMP open channel requests, you can use this + * function process all of those requests immediately. + **/ + forceProcessHrmpOpen: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Accept a pending open channel request from the given sender. + * + * The channel will be opened only on the next session boundary. + **/ + hrmpAcceptOpenChannel: AugmentedSubmittable<(sender: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * This cancels a pending open channel request. It can be canceled be either of the sender + * or the recipient for that request. The origin must be either of those. + * + * The cancellation happens immediately. It is not possible to cancel the request if it is + * already accepted. + **/ + hrmpCancelOpenRequest: AugmentedSubmittable<(channelId: PolkadotParachainPrimitivesHrmpChannelId | { sender?: any; recipient?: any } | string | Uint8Array) => SubmittableExtrinsic, [PolkadotParachainPrimitivesHrmpChannelId]>; + /** + * Initiate unilateral closing of a channel. The origin must be either the sender or the + * recipient in the channel being closed. + * + * The closure can only happen on a session change. + **/ + hrmpCloseChannel: AugmentedSubmittable<(channelId: PolkadotParachainPrimitivesHrmpChannelId | { sender?: any; recipient?: any } | string | Uint8Array) => SubmittableExtrinsic, [PolkadotParachainPrimitivesHrmpChannelId]>; + /** + * Initiate opening a channel from a parachain to a given recipient with given channel + * parameters. + * + * - `proposed_max_capacity` - specifies how many messages can be in the channel at once. + * - `proposed_max_message_size` - specifies the maximum size of the messages. + * + * These numbers are a subject to the relay-chain configuration limits. + * + * The channel can be opened only after the recipient confirms it and only on a session + * change. + **/ + hrmpInitOpenChannel: AugmentedSubmittable<(recipient: u32 | AnyNumber | Uint8Array, proposedMaxCapacity: u32 | AnyNumber | Uint8Array, proposedMaxMessageSize: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + identity: { + /** + * Add a registrar to the system. + * + * The dispatch origin for this call must be `T::RegistrarOrigin`. + * + * - `account`: the account of the registrar. + * + * Emits `RegistrarAdded` if successful. + * + * # + * - `O(R)` where `R` registrar-count (governance-bounded and code-bounded). + * - One storage mutation (codec `O(R)`). + * - One event. + * # + **/ + addRegistrar: AugmentedSubmittable<(account: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Add the given account to the sender's subs. + * + * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated + * to the sender. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * sub identity of `sub`. + **/ + addSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Data]>; + /** + * Cancel a previous request. + * + * Payment: A previously reserved deposit is returned on success. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a + * registered identity. + * + * - `reg_index`: The index of the registrar whose judgement is no longer requested. + * + * Emits `JudgementUnrequested` if successful. + * + * # + * - `O(R + X)`. + * - One balance-reserve operation. + * - One storage mutation `O(R + X)`. + * - One event + * # + **/ + cancelRequest: AugmentedSubmittable<(regIndex: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Clear an account's identity info and all sub-accounts and return all deposits. + * + * Payment: All reserved balances on the account are returned. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * identity. + * + * Emits `IdentityCleared` if successful. + * + * # + * - `O(R + S + X)` + * - where `R` registrar-count (governance-bounded). + * - where `S` subs-count (hard- and deposit-bounded). + * - where `X` additional-field-count (deposit-bounded and code-bounded). + * - One balance-unreserve operation. + * - `2` storage reads and `S + 2` storage deletions. + * - One event. + * # + **/ + clearIdentity: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Remove an account's identity and sub-account information and slash the deposits. + * + * Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by + * `Slash`. Verification request deposits are not returned; they should be cancelled + * manually using `cancel_request`. + * + * The dispatch origin for this call must match `T::ForceOrigin`. + * + * - `target`: the account whose identity the judgement is upon. This must be an account + * with a registered identity. + * + * Emits `IdentityKilled` if successful. + * + * # + * - `O(R + S + X)`. + * - One balance-reserve operation. + * - `S + 2` storage mutations. + * - One event. + * # + **/ + killIdentity: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress]>; + /** + * Provide a judgement for an account's identity. + * + * The dispatch origin for this call must be _Signed_ and the sender must be the account + * of the registrar whose index is `reg_index`. + * + * - `reg_index`: the index of the registrar whose judgement is being made. + * - `target`: the account whose identity the judgement is upon. This must be an account + * with a registered identity. + * - `judgement`: the judgement of the registrar of index `reg_index` about `target`. + * + * Emits `JudgementGiven` if successful. + * + * # + * - `O(R + X)`. + * - One balance-transfer operation. + * - Up to one account-lookup operation. + * - Storage: 1 read `O(R)`, 1 mutate `O(R + X)`. + * - One event. + * # + **/ + provideJudgement: AugmentedSubmittable<(regIndex: Compact | AnyNumber | Uint8Array, target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, judgement: PalletIdentityJudgement | { Unknown: any } | { FeePaid: any } | { Reasonable: any } | { KnownGood: any } | { OutOfDate: any } | { LowQuality: any } | { Erroneous: any } | string | Uint8Array) => SubmittableExtrinsic, [Compact, MultiAddress, PalletIdentityJudgement]>; + /** + * Remove the sender as a sub-account. + * + * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated + * to the sender (*not* the original depositor). + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * super-identity. + * + * NOTE: This should not normally be used, but is provided in the case that the non- + * controller of an account is maliciously registered as a sub-account. + **/ + quitSub: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Remove the given account from the sender's subs. + * + * Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated + * to the sender. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * sub identity of `sub`. + **/ + removeSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress]>; + /** + * Alter the associated name of the given sub-account. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * sub identity of `sub`. + **/ + renameSub: AugmentedSubmittable<(sub: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, data: Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Data]>; + /** + * Request a judgement from a registrar. + * + * Payment: At most `max_fee` will be reserved for payment to the registrar if judgement + * given. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a + * registered identity. + * + * - `reg_index`: The index of the registrar whose judgement is requested. + * - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as: + * + * ```nocompile + * Self::registrars().get(reg_index).unwrap().fee + * ``` + * + * Emits `JudgementRequested` if successful. + * + * # + * - `O(R + X)`. + * - One balance-reserve operation. + * - Storage: 1 read `O(R)`, 1 mutate `O(X + R)`. + * - One event. + * # + **/ + requestJudgement: AugmentedSubmittable<(regIndex: Compact | AnyNumber | Uint8Array, maxFee: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * Change the account associated with a registrar. + * + * The dispatch origin for this call must be _Signed_ and the sender must be the account + * of the registrar whose index is `index`. + * + * - `index`: the index of the registrar whose fee is to be set. + * - `new`: the new account ID. + * + * # + * - `O(R)`. + * - One storage mutation `O(R)`. + * - Benchmark: 8.823 + R * 0.32 µs (min squares analysis) + * # + **/ + setAccountId: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [Compact, AccountId32]>; + /** + * Set the fee required for a judgement to be requested from a registrar. + * + * The dispatch origin for this call must be _Signed_ and the sender must be the account + * of the registrar whose index is `index`. + * + * - `index`: the index of the registrar whose fee is to be set. + * - `fee`: the new fee. + * + * # + * - `O(R)`. + * - One storage mutation `O(R)`. + * - Benchmark: 7.315 + R * 0.329 µs (min squares analysis) + * # + **/ + setFee: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, fee: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * Set the field information for a registrar. + * + * The dispatch origin for this call must be _Signed_ and the sender must be the account + * of the registrar whose index is `index`. + * + * - `index`: the index of the registrar whose fee is to be set. + * - `fields`: the fields that the registrar concerns themselves with. + * + * # + * - `O(R)`. + * - One storage mutation `O(R)`. + * - Benchmark: 7.464 + R * 0.325 µs (min squares analysis) + * # + **/ + setFields: AugmentedSubmittable<(index: Compact | AnyNumber | Uint8Array, fields: PalletIdentityBitFlags) => SubmittableExtrinsic, [Compact, PalletIdentityBitFlags]>; + /** + * Set an account's identity information and reserve the appropriate deposit. + * + * If the account already has identity information, the deposit is taken as part payment + * for the new deposit. + * + * The dispatch origin for this call must be _Signed_. + * + * - `info`: The identity information. + * + * Emits `IdentitySet` if successful. + * + * # + * - `O(X + X' + R)` + * - where `X` additional-field-count (deposit-bounded and code-bounded) + * - where `R` judgements-count (registrar-count-bounded) + * - One balance reserve operation. + * - One storage mutation (codec-read `O(X' + R)`, codec-write `O(X + R)`). + * - One event. + * # + **/ + setIdentity: AugmentedSubmittable<(info: PalletIdentityIdentityInfo | { additional?: any; display?: any; legal?: any; web?: any; riot?: any; email?: any; pgpFingerprint?: any; image?: any; twitter?: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletIdentityIdentityInfo]>; + /** + * Set the sub-accounts of the sender. + * + * Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned + * and an amount `SubAccountDeposit` will be reserved for each item in `subs`. + * + * The dispatch origin for this call must be _Signed_ and the sender must have a registered + * identity. + * + * - `subs`: The identity's (new) sub-accounts. + * + * # + * - `O(P + S)` + * - where `P` old-subs-count (hard- and deposit-bounded). + * - where `S` subs-count (hard- and deposit-bounded). + * - At most one balance operations. + * - DB: + * - `P + S` storage mutations (codec complexity `O(1)`) + * - One storage read (codec complexity `O(P)`). + * - One storage write (codec complexity `O(S)`). + * - One storage-exists (`IdentityOf::contains_key`). + * # + **/ + setSubs: AugmentedSubmittable<(subs: Vec> | ([AccountId32 | string | Uint8Array, Data | { None: any } | { Raw: any } | { BlakeTwo256: any } | { Sha256: any } | { Keccak256: any } | { ShaThree256: any } | string | Uint8Array])[]) => SubmittableExtrinsic, [Vec>]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + imOnline: { + /** + * # + * - Complexity: `O(K + E)` where K is length of `Keys` (heartbeat.validators_len) and E is + * length of `heartbeat.network_state.external_address` + * - `O(K)`: decoding of length `K` + * - `O(E)`: decoding/encoding of length `E` + * - DbReads: pallet_session `Validators`, pallet_session `CurrentIndex`, `Keys`, + * `ReceivedHeartbeats` + * - DbWrites: `ReceivedHeartbeats` + * # + **/ + heartbeat: AugmentedSubmittable<(heartbeat: PalletImOnlineHeartbeat | { blockNumber?: any; networkState?: any; sessionIndex?: any; authorityIndex?: any; validatorsLen?: any } | string | Uint8Array, signature: PalletImOnlineSr25519AppSr25519Signature | string | Uint8Array) => SubmittableExtrinsic, [PalletImOnlineHeartbeat, PalletImOnlineSr25519AppSr25519Signature]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + indices: { + /** + * Assign an previously unassigned index. + * + * Payment: `Deposit` is reserved from the sender account. + * + * The dispatch origin for this call must be _Signed_. + * + * - `index`: the index to be claimed. This must not be in use. + * + * Emits `IndexAssigned` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - One reserve operation. + * - One event. + * ------------------- + * - DB Weight: 1 Read/Write (Accounts) + * # + **/ + claim: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Force an index to an account. This doesn't require a deposit. If the index is already + * held, then any deposit is reimbursed to its current owner. + * + * The dispatch origin for this call must be _Root_. + * + * - `index`: the index to be (re-)assigned. + * - `new`: the new owner of the index. This function is a no-op if it is equal to sender. + * - `freeze`: if set to `true`, will freeze the index so it cannot be transferred. + * + * Emits `IndexAssigned` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - Up to one reserve operation. + * - One event. + * ------------------- + * - DB Weight: + * - Reads: Indices Accounts, System Account (original owner) + * - Writes: Indices Accounts, System Account (original owner) + * # + **/ + forceTransfer: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array, index: u32 | AnyNumber | Uint8Array, freeze: bool | boolean | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32, bool]>; + /** + * Free up an index owned by the sender. + * + * Payment: Any previous deposit placed for the index is unreserved in the sender account. + * + * The dispatch origin for this call must be _Signed_ and the sender must own the index. + * + * - `index`: the index to be freed. This must be owned by the sender. + * + * Emits `IndexFreed` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - One reserve operation. + * - One event. + * ------------------- + * - DB Weight: 1 Read/Write (Accounts) + * # + **/ + free: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Freeze an index so it will always point to the sender account. This consumes the + * deposit. + * + * The dispatch origin for this call must be _Signed_ and the signing account must have a + * non-frozen account `index`. + * + * - `index`: the index to be frozen in place. + * + * Emits `IndexFrozen` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - Up to one slash operation. + * - One event. + * ------------------- + * - DB Weight: 1 Read/Write (Accounts) + * # + **/ + freeze: AugmentedSubmittable<(index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Assign an index already owned by the sender to another account. The balance reservation + * is effectively transferred to the new account. + * + * The dispatch origin for this call must be _Signed_. + * + * - `index`: the index to be re-assigned. This must be owned by the sender. + * - `new`: the new owner of the index. This function is a no-op if it is equal to sender. + * + * Emits `IndexAssigned` if successful. + * + * # + * - `O(1)`. + * - One storage mutation (codec `O(1)`). + * - One transfer operation. + * - One event. + * ------------------- + * - DB Weight: + * - Reads: Indices Accounts, System Account (recipient) + * - Writes: Indices Accounts, System Account (recipient) + * # + **/ + transfer: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + initializer: { + /** + * Issue a signal to the consensus engine to forcibly act as though all parachain + * blocks in all relay chain blocks up to and including the given number in the current + * chain are valid and should be finalized. + **/ + forceApprove: AugmentedSubmittable<(upTo: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + multisig: { + /** + * 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. + * + * # + * - `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`. + * ---------------------------------- + * - DB Weight: + * - Read: Multisig Storage, [Caller Account] + * - Write: Multisig Storage, [Caller Account] + * # + **/ + approveAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec | (AccountId32 | string | Uint8Array)[], maybeTimepoint: Option | null | object | string | Uint8Array, callHash: U8aFixed | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u16, Vec, Option, U8aFixed, u64]>; + /** + * 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. + * + * # + * - `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`. + * ------------------------------- + * - DB Weight: + * - Reads: Multisig Storage, [Caller Account], Calls (if `store_call`) + * - Writes: Multisig Storage, [Caller Account], Calls (if `store_call`) + * - Plus Call Weight + * # + **/ + asMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec | (AccountId32 | string | Uint8Array)[], maybeTimepoint: Option | null | object | string | Uint8Array, call: Bytes | string | Uint8Array, storeCall: bool | boolean | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u16, Vec, Option, Bytes, bool, u64]>; + /** + * 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. + * + * # + * O(Z + C) where Z is the length of the call and C its execution weight. + * ------------------------------- + * - DB Weight: None + * - Plus Call Weight + * # + **/ + asMultiThreshold1: AugmentedSubmittable<(otherSignatories: Vec | (AccountId32 | string | Uint8Array)[], call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [Vec, Call]>; + /** + * 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. + * + * # + * - `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. + * ---------------------------------- + * - DB Weight: + * - Read: Multisig Storage, [Caller Account], Refund Account, Calls + * - Write: Multisig Storage, [Caller Account], Refund Account, Calls + * # + **/ + cancelAsMulti: AugmentedSubmittable<(threshold: u16 | AnyNumber | Uint8Array, otherSignatories: Vec | (AccountId32 | string | Uint8Array)[], timepoint: PalletMultisigTimepoint | { height?: any; index?: any } | string | Uint8Array, callHash: U8aFixed | string | Uint8Array) => SubmittableExtrinsic, [u16, Vec, PalletMultisigTimepoint, U8aFixed]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + paraInclusion: { + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + paraInherent: { + /** + * Enter the paras inherent. This will process bitfields and backed candidates. + **/ + enter: AugmentedSubmittable<(data: PolkadotPrimitivesV1InherentData | { bitfields?: any; backedCandidates?: any; disputes?: any; parentHeader?: any } | string | Uint8Array) => SubmittableExtrinsic, [PolkadotPrimitivesV1InherentData]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + paras: { + /** + * Note a new block head for para within the context of the current block. + **/ + forceNoteNewHead: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, newHead: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + /** + * Put a parachain directly into the next session's action queue. + * We can't queue it any sooner than this without going into the + * initializer... + **/ + forceQueueAction: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Schedule an upgrade as if it was scheduled in the given relay parent block. + **/ + forceScheduleCodeUpgrade: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, newCode: Bytes | string | Uint8Array, relayParentNumber: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, Bytes, u32]>; + /** + * Set the storage for the parachain validation code immediately. + **/ + forceSetCurrentCode: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, newCode: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + /** + * Set the storage for the current parachain head data immediately. + **/ + forceSetCurrentHead: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, newHead: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes]>; + /** + * Includes a statement for a PVF pre-checking vote. Potentially, finalizes the vote and + * enacts the results if that was the last vote before achieving the supermajority. + **/ + includePvfCheckStatement: AugmentedSubmittable<(stmt: PolkadotPrimitivesV1PvfCheckStatement | { accept?: any; subject?: any; sessionIndex?: any; validatorIndex?: any } | string | Uint8Array, signature: PolkadotPrimitivesV0ValidatorAppSignature | string | Uint8Array) => SubmittableExtrinsic, [PolkadotPrimitivesV1PvfCheckStatement, PolkadotPrimitivesV0ValidatorAppSignature]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + parasShared: { + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + phragmenElection: { + /** + * Clean all voters who are defunct (i.e. they do not serve any purpose at all). The + * deposit of the removed voters are returned. + * + * This is an root function to be used only for cleaning the state. + * + * The dispatch origin of this call must be root. + * + * # + * The total number of voters and those that are defunct must be provided as witness data. + * # + **/ + cleanDefunctVoters: AugmentedSubmittable<(numVoters: u32 | AnyNumber | Uint8Array, numDefunct: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Remove a particular member from the set. This is effective immediately and the bond of + * the outgoing member is slashed. + * + * If a runner-up is available, then the best runner-up will be removed and replaces the + * outgoing member. Otherwise, a new phragmen election is started. + * + * The dispatch origin of this call must be root. + * + * Note that this does not affect the designated block number of the next election. + * + * # + * If we have a replacement, we use a small weight. Else, since this is a root call and + * will go into phragmen, we assume full block for now. + * # + **/ + removeMember: AugmentedSubmittable<(who: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, hasReplacement: bool | boolean | Uint8Array) => SubmittableExtrinsic, [MultiAddress, bool]>; + /** + * Remove `origin` as a voter. + * + * This removes the lock and returns the deposit. + * + * The dispatch origin of this call must be signed and be a voter. + **/ + removeVoter: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Renounce one's intention to be a candidate for the next election round. 3 potential + * outcomes exist: + * + * - `origin` is a candidate and not elected in any set. In this case, the deposit is + * unreserved, returned and origin is removed as a candidate. + * - `origin` is a current runner-up. In this case, the deposit is unreserved, returned and + * origin is removed as a runner-up. + * - `origin` is a current member. In this case, the deposit is unreserved and origin is + * removed as a member, consequently not being a candidate for the next round anymore. + * Similar to [`remove_member`](Self::remove_member), if replacement runners exists, they + * are immediately used. If the prime is renouncing, then no prime will exist until the + * next round. + * + * The dispatch origin of this call must be signed, and have one of the above roles. + * + * # + * The type of renouncing must be provided as witness data. + * # + **/ + renounceCandidacy: AugmentedSubmittable<(renouncing: PalletElectionsPhragmenRenouncing | { Member: any } | { RunnerUp: any } | { Candidate: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletElectionsPhragmenRenouncing]>; + /** + * Submit oneself for candidacy. A fixed amount of deposit is recorded. + * + * All candidates are wiped at the end of the term. They either become a member/runner-up, + * or leave the system while their deposit is slashed. + * + * The dispatch origin of this call must be signed. + * + * ### Warning + * + * Even if a candidate ends up being a member, they must call [`Call::renounce_candidacy`] + * to get their deposit back. Losing the spot in an election will always lead to a slash. + * + * # + * The number of current candidates must be provided as witness data. + * # + **/ + submitCandidacy: AugmentedSubmittable<(candidateCount: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Vote for a set of candidates for the upcoming round of election. This can be called to + * set the initial votes, or update already existing votes. + * + * Upon initial voting, `value` units of `who`'s balance is locked and a deposit amount is + * reserved. The deposit is based on the number of votes and can be updated over time. + * + * The `votes` should: + * - not be empty. + * - be less than the number of possible candidates. Note that all current members and + * runners-up are also automatically candidates for the next round. + * + * If `value` is more than `who`'s total balance, then the maximum of the two is used. + * + * The dispatch origin of this call must be signed. + * + * ### Warning + * + * It is the responsibility of the caller to **NOT** place all of their balance into the + * lock and keep some for further operations. + * + * # + * We assume the maximum weight among all 3 cases: vote_equal, vote_more and vote_less. + * # + **/ + vote: AugmentedSubmittable<(votes: Vec | (AccountId32 | string | Uint8Array)[], value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + preimage: { + /** + * Register a preimage on-chain. + * + * If the preimage was previously requested, no fees or deposits are taken for providing + * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage. + **/ + notePreimage: AugmentedSubmittable<(bytes: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Request a preimage be uploaded to the chain without paying any fees or deposits. + * + * If the preimage requests has already been provided on-chain, we unreserve any deposit + * a user may have paid, and take the control of the preimage out of their hands. + **/ + requestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Clear an unrequested preimage from the runtime storage. + **/ + unnotePreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Clear a previously made request for a preimage. + * + * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`. + **/ + unrequestPreimage: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + proxy: { + /** + * 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. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + addProxy: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, proxyType: PolkadotRuntimeProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'IdentityJudgement' | 'CancelProxy' | 'Auction' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, PolkadotRuntimeProxyType, u32]>; + /** + * 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. + * + * # + * Weight is a function of: + * - A: the number of announcements made. + * - P: the number of proxies the user has. + * # + **/ + announce: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, H256]>; + /** + * 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. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + * TODO: Might be over counting 1 read + **/ + anonymous: AugmentedSubmittable<(proxyType: PolkadotRuntimeProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'IdentityJudgement' | 'CancelProxy' | 'Auction' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array, index: u16 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [PolkadotRuntimeProxyType, u32, u16]>; + /** + * Removes a previously spawned anonymous 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 + * `anonymous` with corresponding parameters. + * + * - `spawner`: The account that originally called `anonymous` to create this account. + * - `index`: The disambiguation index originally passed to `anonymous`. Probably `0`. + * - `proxy_type`: The proxy type originally passed to `anonymous`. + * - `height`: The height of the chain when the call to `anonymous` was processed. + * - `ext_index`: The extrinsic index in which the call to `anonymous` was processed. + * + * Fails with `NoPermission` in case the caller is not a previously created anonymous + * account whose `anonymous` call has corresponding parameters. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + killAnonymous: AugmentedSubmittable<(spawner: AccountId32 | string | Uint8Array, proxyType: PolkadotRuntimeProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'IdentityJudgement' | 'CancelProxy' | 'Auction' | number | Uint8Array, index: u16 | AnyNumber | Uint8Array, height: Compact | AnyNumber | Uint8Array, extIndex: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, PolkadotRuntimeProxyType, u16, Compact, Compact]>; + /** + * Dispatch the given `call` from an account that the sender is authorised 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. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + proxy: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, forceProxyType: Option | null | object | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, Option, Call]>; + /** + * 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. + * + * # + * Weight is a function of: + * - A: the number of announcements made. + * - P: the number of proxies the user has. + * # + **/ + proxyAnnounced: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, real: AccountId32 | string | Uint8Array, forceProxyType: Option | null | object | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32, Option, Call]>; + /** + * 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. + * + * # + * Weight is a function of: + * - A: the number of announcements made. + * - P: the number of proxies the user has. + * # + **/ + rejectAnnouncement: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, H256]>; + /** + * 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. + * + * # + * Weight is a function of: + * - A: the number of announcements made. + * - P: the number of proxies the user has. + * # + **/ + removeAnnouncement: AugmentedSubmittable<(real: AccountId32 | string | Uint8Array, callHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, H256]>; + /** + * 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 `anonymous`, however if done, then + * the unreserved fees will be inaccessible. **All access to this account will be lost.** + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + removeProxies: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * 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. + * + * # + * Weight is a function of the number of proxies the user has (P). + * # + **/ + removeProxy: AugmentedSubmittable<(delegate: AccountId32 | string | Uint8Array, proxyType: PolkadotRuntimeProxyType | 'Any' | 'NonTransfer' | 'Governance' | 'Staking' | 'IdentityJudgement' | 'CancelProxy' | 'Auction' | number | Uint8Array, delay: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, PolkadotRuntimeProxyType, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + registrar: { + /** + * Deregister a Para Id, freeing all data and returning any deposit. + * + * The caller must be Root, the `para` owner, or the `para` itself. The para must be a parathread. + **/ + deregister: AugmentedSubmittable<(id: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Force the registration of a Para Id on the relay chain. + * + * This function must be called by a Root origin. + * + * The deposit taken can be specified for this registration. Any `ParaId` + * can be registered, including sub-1000 IDs which are System Parachains. + **/ + forceRegister: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array, deposit: u128 | AnyNumber | Uint8Array, id: u32 | AnyNumber | Uint8Array, genesisHead: Bytes | string | Uint8Array, validationCode: Bytes | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, u128, u32, Bytes, Bytes]>; + /** + * Remove a manager lock from a para. This will allow the manager of a + * previously locked para to deregister or swap a para without using governance. + * + * Can only be called by the Root origin. + **/ + forceRemoveLock: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Register head data and validation code for a reserved Para Id. + * + * ## Arguments + * - `origin`: Must be called by a `Signed` origin. + * - `id`: The para ID. Must be owned/managed by the `origin` signing account. + * - `genesis_head`: The genesis head data of the parachain/thread. + * - `validation_code`: The initial validation code of the parachain/thread. + * + * ## Deposits/Fees + * The origin signed account must reserve a corresponding deposit for the registration. Anything already + * reserved previously for this para ID is accounted for. + * + * ## Events + * The `Registered` event is emitted in case of success. + **/ + register: AugmentedSubmittable<(id: u32 | AnyNumber | Uint8Array, genesisHead: Bytes | string | Uint8Array, validationCode: Bytes | string | Uint8Array) => SubmittableExtrinsic, [u32, Bytes, Bytes]>; + /** + * Reserve a Para Id on the relay chain. + * + * This function will reserve a new Para Id to be owned/managed by the origin account. + * The origin account is able to register head data and validation code using `register` to create + * a parathread. Using the Slots pallet, a parathread can then be upgraded to get a parachain slot. + * + * ## Arguments + * - `origin`: Must be called by a `Signed` origin. Becomes the manager/owner of the new para ID. + * + * ## Deposits/Fees + * The origin must reserve a deposit of `ParaDeposit` for the registration. + * + * ## Events + * The `Reserved` event is emitted in case of success, which provides the ID reserved for use. + **/ + reserve: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Swap a parachain with another parachain or parathread. + * + * The origin must be Root, the `para` owner, or the `para` itself. + * + * The swap will happen only if there is already an opposite swap pending. If there is not, + * the swap will be stored in the pending swaps map, ready for a later confirmatory swap. + * + * The `ParaId`s remain mapped to the same head data and code so external code can rely on + * `ParaId` to be a long-term identifier of a notional "parachain". However, their + * scheduling info (i.e. whether they're a parathread or parachain), auction information + * and the auction deposit are switched. + **/ + swap: AugmentedSubmittable<(id: u32 | AnyNumber | Uint8Array, other: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + scheduler: { + /** + * Cancel an anonymously scheduled task. + **/ + cancel: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Cancel a named scheduled task. + **/ + cancelNamed: AugmentedSubmittable<(id: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Anonymously schedule a task. + **/ + schedule: AugmentedSubmittable<(when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, Option>, u8, FrameSupportScheduleMaybeHashed]>; + /** + * Anonymously schedule a task after a delay. + * + * # + * Same as [`schedule`]. + * # + **/ + scheduleAfter: AugmentedSubmittable<(after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, Option>, u8, FrameSupportScheduleMaybeHashed]>; + /** + * Schedule a named task. + **/ + scheduleNamed: AugmentedSubmittable<(id: Bytes | string | Uint8Array, when: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [Bytes, u32, Option>, u8, FrameSupportScheduleMaybeHashed]>; + /** + * Schedule a named task after a delay. + * + * # + * Same as [`schedule_named`](Self::schedule_named). + * # + **/ + scheduleNamedAfter: AugmentedSubmittable<(id: Bytes | string | Uint8Array, after: u32 | AnyNumber | Uint8Array, maybePeriodic: Option> | null | object | string | Uint8Array, priority: u8 | AnyNumber | Uint8Array, call: FrameSupportScheduleMaybeHashed | { Value: any } | { Hash: any } | string | Uint8Array) => SubmittableExtrinsic, [Bytes, u32, Option>, u8, FrameSupportScheduleMaybeHashed]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + session: { + /** + * Removes any session key(s) of the function caller. + * + * This doesn't take effect until the next session. + * + * The dispatch origin of this function must be Signed and the account must be either be + * convertible to a validator ID using the chain's typical addressing system (this usually + * means being a controller account) or directly convertible into a validator ID (which + * usually means being a stash account). + * + * # + * - Complexity: `O(1)` in number of key types. Actual cost depends on the number of length + * of `T::Keys::key_ids()` which is fixed. + * - DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account` + * - DbWrites: `NextKeys`, `origin account` + * - DbWrites per key id: `KeyOwner` + * # + **/ + purgeKeys: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Sets the session key(s) of the function caller to `keys`. + * Allows an account to set its session key prior to becoming a validator. + * This doesn't take effect until the next session. + * + * The dispatch origin of this function must be signed. + * + * # + * - Complexity: `O(1)`. Actual cost depends on the number of length of + * `T::Keys::key_ids()` which is fixed. + * - DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys` + * - DbWrites: `origin account`, `NextKeys` + * - DbReads per key id: `KeyOwner` + * - DbWrites per key id: `KeyOwner` + * # + **/ + setKeys: AugmentedSubmittable<(keys: PolkadotRuntimeSessionKeys | { grandpa?: any; babe?: any; imOnline?: any; paraValidator?: any; paraAssignment?: any; authorityDiscovery?: any } | string | Uint8Array, proof: Bytes | string | Uint8Array) => SubmittableExtrinsic, [PolkadotRuntimeSessionKeys, Bytes]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + slots: { + /** + * Clear all leases for a Para Id, refunding any deposits back to the original owners. + * + * The dispatch origin for this call must match `T::ForceOrigin`. + **/ + clearAllLeases: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Just a connect into the `lease_out` call, in case Root wants to force some lease to happen + * independently of any other on-chain mechanism to use it. + * + * The dispatch origin for this call must match `T::ForceOrigin`. + **/ + forceLease: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array, leaser: AccountId32 | string | Uint8Array, amount: u128 | AnyNumber | Uint8Array, periodBegin: u32 | AnyNumber | Uint8Array, periodCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, AccountId32, u128, u32, u32]>; + /** + * Try to onboard a parachain that has a lease for the current lease period. + * + * This function can be useful if there was some state issue with a para that should + * have onboarded, but was unable to. As long as they have a lease period, we can + * let them onboard from here. + * + * Origin must be signed, but can be called by anyone. + **/ + triggerOnboard: AugmentedSubmittable<(para: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + staking: { + /** + * Take the origin account as a stash and lock up `value` of its balance. `controller` will + * be the account that controls it. + * + * `value` must be more than the `minimum_balance` specified by `T::Currency`. + * + * The dispatch origin for this call must be _Signed_ by the stash account. + * + * Emits `Bonded`. + * # + * - Independent of the arguments. Moderate complexity. + * - O(1). + * - Three extra DB entries. + * + * NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleaned + * unless the `origin` falls below _existential deposit_ and gets removed as dust. + * ------------------ + * # + **/ + bond: AugmentedSubmittable<(controller: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact | AnyNumber | Uint8Array, payee: PalletStakingRewardDestination | { Staked: any } | { Stash: any } | { Controller: any } | { Account: any } | { None: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, Compact, PalletStakingRewardDestination]>; + /** + * Add some extra amount that have appeared in the stash `free_balance` into the balance up + * for staking. + * + * The dispatch origin for this call must be _Signed_ by the stash, not the controller. + * + * Use this if there are additional funds in your stash account that you wish to bond. + * Unlike [`bond`](Self::bond) or [`unbond`](Self::unbond) this function does not impose + * any limitation on the amount that can be added. + * + * Emits `Bonded`. + * + * # + * - Independent of the arguments. Insignificant complexity. + * - O(1). + * # + **/ + bondExtra: AugmentedSubmittable<(maxAdditional: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Cancel enactment of a deferred slash. + * + * Can be called by the `T::SlashCancelOrigin`. + * + * Parameters: era and indices of the slashes for that era to kill. + * + * # + * Complexity: O(U + S) + * with U unapplied slashes weighted with U=1000 + * and S is the number of slash indices to be canceled. + * - Read: Unapplied Slashes + * - Write: Unapplied Slashes + * # + **/ + cancelDeferredSlash: AugmentedSubmittable<(era: u32 | AnyNumber | Uint8Array, slashIndices: Vec | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [u32, Vec]>; + /** + * Declare no desire to either validate or nominate. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * # + * - Independent of the arguments. Insignificant complexity. + * - Contains one read. + * - Writes are limited to the `origin` account key. + * # + **/ + chill: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Declare a `controller` to stop participating as either a validator or nominator. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_, but can be called by anyone. + * + * If the caller is the same as the controller being targeted, then no further checks are + * enforced, and this function behaves just like `chill`. + * + * If the caller is different than the controller being targeted, the following conditions + * must be met: + * * A `ChillThreshold` must be set and checked which defines how close to the max + * nominators or validators we must reach before users can start chilling one-another. + * * A `MaxNominatorCount` and `MaxValidatorCount` must be set which is used to determine + * how close we are to the threshold. + * * A `MinNominatorBond` and `MinValidatorBond` must be set and checked, which determines + * if this is a person that should be chilled because they have not met the threshold + * bond required. + * + * This can be helpful if bond requirements are updated, and we need to remove old users + * who do not satisfy these requirements. + **/ + chillOther: AugmentedSubmittable<(controller: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Force there to be a new era at the end of the next session. After this, it will be + * reset to normal (non-forced) behaviour. + * + * The dispatch origin must be Root. + * + * # Warning + * + * The election process starts multiple blocks before the end of the era. + * If this is called just before a new era is triggered, the election process may not + * have enough blocks to get a result. + * + * # + * - No arguments. + * - Weight: O(1) + * - Write ForceEra + * # + **/ + forceNewEra: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Force there to be a new era at the end of sessions indefinitely. + * + * The dispatch origin must be Root. + * + * # Warning + * + * The election process starts multiple blocks before the end of the era. + * If this is called just before a new era is triggered, the election process may not + * have enough blocks to get a result. + * + * # + * - Weight: O(1) + * - Write: ForceEra + * # + **/ + forceNewEraAlways: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Force there to be no new eras indefinitely. + * + * The dispatch origin must be Root. + * + * # Warning + * + * The election process starts multiple blocks before the end of the era. + * Thus the election process may be ongoing when this is called. In this case the + * election will continue until the next era is triggered. + * + * # + * - No arguments. + * - Weight: O(1) + * - Write: ForceEra + * # + **/ + forceNoEras: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Force a current staker to become completely unstaked, immediately. + * + * The dispatch origin must be Root. + * + * # + * O(S) where S is the number of slashing spans to be removed + * Reads: Bonded, Slashing Spans, Account, Locks + * Writes: Bonded, Slashing Spans (if S > 0), Ledger, Payee, Validators, Nominators, + * Account, Locks Writes Each: SpanSlash * S + * # + **/ + forceUnstake: AugmentedSubmittable<(stash: AccountId32 | string | Uint8Array, numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * Increments the ideal number of validators. + * + * The dispatch origin must be Root. + * + * # + * Same as [`Self::set_validator_count`]. + * # + **/ + increaseValidatorCount: AugmentedSubmittable<(additional: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Remove the given nominations from the calling validator. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * - `who`: A list of nominator stash accounts who are nominating this validator which + * should no longer be nominating this validator. + * + * Note: Making this call only makes sense if you first set the validator preferences to + * block any further nominations. + **/ + kick: AugmentedSubmittable<(who: Vec | (MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Declare the desire to nominate `targets` for the origin controller. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * # + * - The transaction's complexity is proportional to the size of `targets` (N) + * which is capped at CompactAssignments::LIMIT (MAX_NOMINATIONS). + * - Both the reads and writes follow a similar pattern. + * # + **/ + nominate: AugmentedSubmittable<(targets: Vec | (MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Pay out all the stakers behind a single validator for a single era. + * + * - `validator_stash` is the stash account of the validator. Their nominators, up to + * `T::MaxNominatorRewardedPerValidator`, will also receive their rewards. + * - `era` may be any era between `[current_era - history_depth; current_era]`. + * + * The origin of this call must be _Signed_. Any account can call this function, even if + * it is not one of the stakers. + * + * # + * - Time complexity: at most O(MaxNominatorRewardedPerValidator). + * - Contains a limited number of reads and writes. + * ----------- + * N is the Number of payouts for the validator (including the validator) + * Weight: + * - Reward Destination Staked: O(N) + * - Reward Destination Controller (Creating): O(N) + * + * NOTE: weights are assuming that payouts are made to alive stash account (Staked). + * Paying even a dead controller is cheaper weight-wise. We don't do any refunds here. + * # + **/ + payoutStakers: AugmentedSubmittable<(validatorStash: AccountId32 | string | Uint8Array, era: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * Remove all data structures concerning a staker/stash once it is at a state where it can + * be considered `dust` in the staking system. The requirements are: + * + * 1. the `total_balance` of the stash is below existential deposit. + * 2. or, the `ledger.total` of the stash is below existential deposit. + * + * The former can happen in cases like a slash; the latter when a fully unbonded account + * is still receiving staking rewards in `RewardDestination::Staked`. + * + * It can be called by anyone, as long as `stash` meets the above requirements. + * + * Refunds the transaction fees upon successful execution. + **/ + reapStash: AugmentedSubmittable<(stash: AccountId32 | string | Uint8Array, numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [AccountId32, u32]>; + /** + * Rebond a portion of the stash scheduled to be unlocked. + * + * The dispatch origin must be signed by the controller. + * + * # + * - Time complexity: O(L), where L is unlocking chunks + * - Bounded by `MAX_UNLOCKING_CHUNKS`. + * - Storage changes: Can't increase storage, only decrease it. + * # + **/ + rebond: AugmentedSubmittable<(value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Scale up the ideal number of validators by a factor. + * + * The dispatch origin must be Root. + * + * # + * Same as [`Self::set_validator_count`]. + * # + **/ + scaleValidatorCount: AugmentedSubmittable<(factor: Percent | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Percent]>; + /** + * (Re-)set the controller of a stash. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the stash, not the controller. + * + * # + * - Independent of the arguments. Insignificant complexity. + * - Contains a limited number of reads. + * - Writes are limited to the `origin` account key. + * ---------- + * Weight: O(1) + * DB Weight: + * - Read: Bonded, Ledger New Controller, Ledger Old Controller + * - Write: Bonded, Ledger New Controller, Ledger Old Controller + * # + **/ + setController: AugmentedSubmittable<(controller: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress]>; + /** + * Set `HistoryDepth` value. This function will delete any history information + * when `HistoryDepth` is reduced. + * + * Parameters: + * - `new_history_depth`: The new history depth you would like to set. + * - `era_items_deleted`: The number of items that will be deleted by this dispatch. This + * should report all the storage items that will be deleted by clearing old era history. + * Needed to report an accurate weight for the dispatch. Trusted by `Root` to report an + * accurate number. + * + * Origin must be root. + * + * # + * - E: Number of history depths removed, i.e. 10 -> 7 = 3 + * - Weight: O(E) + * - DB Weight: + * - Reads: Current Era, History Depth + * - Writes: History Depth + * - Clear Prefix Each: Era Stakers, EraStakersClipped, ErasValidatorPrefs + * - Writes Each: ErasValidatorReward, ErasRewardPoints, ErasTotalStake, + * ErasStartSessionIndex + * # + **/ + setHistoryDepth: AugmentedSubmittable<(newHistoryDepth: Compact | AnyNumber | Uint8Array, eraItemsDeleted: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Compact]>; + /** + * Set the validators who cannot be slashed (if any). + * + * The dispatch origin must be Root. + * + * # + * - O(V) + * - Write: Invulnerables + * # + **/ + setInvulnerables: AugmentedSubmittable<(invulnerables: Vec | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * (Re-)set the payment target for a controller. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * # + * - Independent of the arguments. Insignificant complexity. + * - Contains a limited number of reads. + * - Writes are limited to the `origin` account key. + * --------- + * - Weight: O(1) + * - DB Weight: + * - Read: Ledger + * - Write: Payee + * # + **/ + setPayee: AugmentedSubmittable<(payee: PalletStakingRewardDestination | { Staked: any } | { Stash: any } | { Controller: any } | { Account: any } | { None: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletStakingRewardDestination]>; + /** + * Update the various staking configurations . + * + * * `min_nominator_bond`: The minimum active bond needed to be a nominator. + * * `min_validator_bond`: The minimum active bond needed to be a validator. + * * `max_nominator_count`: The max number of users who can be a nominator at once. When + * set to `None`, no limit is enforced. + * * `max_validator_count`: The max number of users who can be a validator at once. When + * set to `None`, no limit is enforced. + * * `chill_threshold`: The ratio of `max_nominator_count` or `max_validator_count` which + * should be filled in order for the `chill_other` transaction to work. + * * `min_commission`: The minimum amount of commission that each validators must maintain. + * This is checked only upon calling `validate`. Existing validators are not affected. + * + * Origin must be Root to call this function. + * + * NOTE: Existing nominators and validators will not be affected by this update. + * to kick people under the new limits, `chill_other` should be called. + **/ + setStakingConfigs: AugmentedSubmittable<(minNominatorBond: u128 | AnyNumber | Uint8Array, minValidatorBond: u128 | AnyNumber | Uint8Array, maxNominatorCount: Option | null | object | string | Uint8Array, maxValidatorCount: Option | null | object | string | Uint8Array, chillThreshold: Option | null | object | string | Uint8Array, minCommission: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u128, u128, Option, Option, Option, Perbill]>; + /** + * Sets the ideal number of validators. + * + * The dispatch origin must be Root. + * + * # + * Weight: O(1) + * Write: Validator Count + * # + **/ + setValidatorCount: AugmentedSubmittable<(updated: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Schedule a portion of the stash to be unlocked ready for transfer out after the bond + * period ends. If this leaves an amount actively bonded less than + * T::Currency::minimum_balance(), then it is increased to the full amount. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + * + * Once the unlock period is done, you can call `withdraw_unbonded` to actually move + * the funds out of management ready for transfer. + * + * No more than a limited number of unlocking chunks (see `MAX_UNLOCKING_CHUNKS`) + * can co-exists at the same time. In that case, [`Call::withdraw_unbonded`] need + * to be called first to remove some of the chunks (if possible). + * + * If a user encounters the `InsufficientBond` error when calling this extrinsic, + * they should call `chill` first in order to free up their bonded funds. + * + * Emits `Unbonded`. + * + * See also [`Call::withdraw_unbonded`]. + **/ + unbond: AugmentedSubmittable<(value: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Declare the desire to validate for the origin controller. + * + * Effects will be felt at the beginning of the next era. + * + * The dispatch origin for this call must be _Signed_ by the controller, not the stash. + **/ + validate: AugmentedSubmittable<(prefs: PalletStakingValidatorPrefs | { commission?: any; blocked?: any } | string | Uint8Array) => SubmittableExtrinsic, [PalletStakingValidatorPrefs]>; + /** + * Remove any unlocked chunks from the `unlocking` queue from our management. + * + * This essentially frees up that balance to be used by the stash account to do + * whatever it wants. + * + * The dispatch origin for this call must be _Signed_ by the controller. + * + * Emits `Withdrawn`. + * + * See also [`Call::unbond`]. + * + * # + * Complexity O(S) where S is the number of slashing spans to remove + * NOTE: Weight annotation is the kill scenario, we refund otherwise. + * # + **/ + withdrawUnbonded: AugmentedSubmittable<(numSlashingSpans: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + system: { + /** + * A dispatch that will fill the block weight up to the given ratio. + **/ + fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Perbill]>; + /** + * Kill all storage items with a key that starts with the given prefix. + * + * **NOTE:** We rely on the Root origin to provide us the number of subkeys under + * the prefix we are removing to accurately calculate the weight of this function. + **/ + killPrefix: AugmentedSubmittable<(prefix: Bytes | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, u32]>; + /** + * Kill some items from storage. + **/ + killStorage: AugmentedSubmittable<(keys: Vec | (Bytes | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Make some on-chain remark. + * + * # + * - `O(1)` + * # + **/ + remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Make some on-chain remark and emit event. + * + * # + * - `O(b)` where b is the length of the remark. + * - 1 event. + * # + **/ + remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Set the new runtime code. + * + * # + * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code` + * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is + * expensive). + * - 1 storage write (codec `O(C)`). + * - 1 digest item. + * - 1 event. + * The weight of this function is dependent on the runtime, but generally this is very + * expensive. We will treat this as a full block. + * # + **/ + setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Set the new runtime code without doing any checks of the given `code`. + * + * # + * - `O(C)` where `C` length of `code` + * - 1 storage write (codec `O(C)`). + * - 1 digest item. + * - 1 event. + * The weight of this function is dependent on the runtime. We will treat this as a full + * block. # + **/ + setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes]>; + /** + * Set the number of pages in the WebAssembly environment's heap. + **/ + setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64]>; + /** + * Set some items of storage. + **/ + setStorage: AugmentedSubmittable<(items: Vec> | ([Bytes | string | Uint8Array, Bytes | string | Uint8Array])[]) => SubmittableExtrinsic, [Vec>]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + technicalCommittee: { + /** + * Close a vote that is either approved, disapproved or whose voting period has ended. + * + * May be called by any signed account in order to finish voting and close the proposal. + * + * If called before the end of the voting period it will only close the vote if it is + * has enough votes to be approved or disapproved. + * + * If called after the end of the voting period abstentions are counted as rejections + * unless there is a prime member set and the prime member cast an approval. + * + * If the close operation completes successfully with disapproval, the transaction fee will + * be waived. Otherwise execution of the approved operation will be charged to the caller. + * + * + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed + * proposal. + * + `length_bound`: The upper bound for the length of the proposal in storage. Checked via + * `storage::read` so it is `size_of::() == 4` larger than the pure length. + * + * # + * ## Weight + * - `O(B + M + P1 + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - `P1` is the complexity of `proposal` preimage. + * - `P2` is proposal-count (code-bounded) + * - DB: + * - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`) + * - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec + * `O(P2)`) + * - any mutations done while executing `proposal` (`P1`) + * - up to 3 events + * # + **/ + close: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, proposalWeightBound: Compact | AnyNumber | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact, Compact, Compact]>; + /** + * Disapprove a proposal, close, and remove it from the system, regardless of its current + * state. + * + * Must be called by the Root origin. + * + * Parameters: + * * `proposal_hash`: The hash of the proposal that should be disapproved. + * + * # + * Complexity: O(P) where P is the number of max proposals + * DB Weight: + * * Reads: Proposals + * * Writes: Voting, Proposals, ProposalOf + * # + **/ + disapproveProposal: AugmentedSubmittable<(proposalHash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Dispatch a proposal from a member using the `Member` origin. + * + * Origin must be a member of the collective. + * + * # + * ## Weight + * - `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching + * `proposal` + * - DB: 1 read (codec `O(M)`) + DB access of `proposal` + * - 1 event + * # + **/ + execute: AugmentedSubmittable<(proposal: Call | { callIndex?: any; args?: any } | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Call, Compact]>; + /** + * Add a new proposal to either be voted on or executed directly. + * + * Requires the sender to be member. + * + * `threshold` determines whether `proposal` is executed directly (`threshold < 2`) + * or put up for voting. + * + * # + * ## Weight + * - `O(B + M + P1)` or `O(B + M + P2)` where: + * - `B` is `proposal` size in bytes (length-fee-bounded) + * - `M` is members-count (code- and governance-bounded) + * - branching is influenced by `threshold` where: + * - `P1` is proposal execution complexity (`threshold < 2`) + * - `P2` is proposals-count (code-bounded) (`threshold >= 2`) + * - DB: + * - 1 storage read `is_member` (codec `O(M)`) + * - 1 storage read `ProposalOf::contains_key` (codec `O(1)`) + * - DB accesses influenced by `threshold`: + * - EITHER storage accesses done by `proposal` (`threshold < 2`) + * - OR proposal insertion (`threshold <= 2`) + * - 1 storage mutation `Proposals` (codec `O(P2)`) + * - 1 storage mutation `ProposalCount` (codec `O(1)`) + * - 1 storage write `ProposalOf` (codec `O(B)`) + * - 1 storage write `Voting` (codec `O(M)`) + * - 1 event + * # + **/ + propose: AugmentedSubmittable<(threshold: Compact | AnyNumber | Uint8Array, proposal: Call | { callIndex?: any; args?: any } | string | Uint8Array, lengthBound: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact, Call, Compact]>; + /** + * Set the collective's membership. + * + * - `new_members`: The new member list. Be nice to the chain and provide it sorted. + * - `prime`: The prime member whose vote sets the default. + * - `old_count`: The upper bound for the previous number of members in storage. Used for + * weight estimation. + * + * Requires root origin. + * + * NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but + * the weight estimations rely on it to estimate dispatchable weight. + * + * # WARNING: + * + * The `pallet-collective` can also be managed by logic outside of the pallet through the + * implementation of the trait [`ChangeMembers`]. + * Any call to `set_members` must be careful that the member set doesn't get out of sync + * with other logic managing the member set. + * + * # + * ## Weight + * - `O(MP + N)` where: + * - `M` old-members-count (code- and governance-bounded) + * - `N` new-members-count (code- and governance-bounded) + * - `P` proposals-count (code-bounded) + * - DB: + * - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the + * members + * - 1 storage read (codec `O(P)`) for reading the proposals + * - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal + * - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one + * # + **/ + setMembers: AugmentedSubmittable<(newMembers: Vec | (AccountId32 | string | Uint8Array)[], prime: Option | null | object | string | Uint8Array, oldCount: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Vec, Option, u32]>; + /** + * Add an aye or nay vote for the sender to the given proposal. + * + * Requires the sender to be a member. + * + * Transaction fees will be waived if the member is voting on any particular proposal + * for the first time and the call is successful. Subsequent vote changes will charge a + * fee. + * # + * ## Weight + * - `O(M)` where `M` is members-count (code- and governance-bounded) + * - DB: + * - 1 storage read `Members` (codec `O(M)`) + * - 1 storage mutation `Voting` (codec `O(M)`) + * - 1 event + * # + **/ + vote: AugmentedSubmittable<(proposal: H256 | string | Uint8Array, index: Compact | AnyNumber | Uint8Array, approve: bool | boolean | Uint8Array) => SubmittableExtrinsic, [H256, Compact, bool]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + technicalMembership: { + /** + * Add a member `who` to the set. + * + * May only be called from `T::AddOrigin`. + **/ + addMember: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Swap out the sending member for some other key `new`. + * + * May only be called from `Signed` origin of a current member. + * + * Prime membership is passed from the origin account to `new`, if extant. + **/ + changeKey: AugmentedSubmittable<(updated: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Remove the prime member if it exists. + * + * May only be called from `T::PrimeOrigin`. + **/ + clearPrime: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Remove a member `who` from the set. + * + * May only be called from `T::RemoveOrigin`. + **/ + removeMember: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Change the membership to a new set, disregarding the existing membership. Be nice and + * pass `members` pre-sorted. + * + * May only be called from `T::ResetOrigin`. + **/ + resetMembers: AugmentedSubmittable<(members: Vec | (AccountId32 | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Set the prime member. Must be a current member. + * + * May only be called from `T::PrimeOrigin`. + **/ + setPrime: AugmentedSubmittable<(who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32]>; + /** + * Swap out one member `remove` for another `add`. + * + * May only be called from `T::SwapOrigin`. + * + * Prime membership is *not* passed from `remove` to `add`, if extant. + **/ + swapMember: AugmentedSubmittable<(remove: AccountId32 | string | Uint8Array, add: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [AccountId32, AccountId32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + timestamp: { + /** + * Set the current time. + * + * This call should be invoked exactly once per block. It will panic at the finalization + * phase, if this call hasn't been invoked by that time. + * + * The timestamp should be greater than the previous one by the amount specified by + * `MinimumPeriod`. + * + * The dispatch origin for this call must be `Inherent`. + * + * # + * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`) + * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in + * `on_finalize`) + * - 1 event handler `on_timestamp_set`. Must be `O(1)`. + * # + **/ + set: AugmentedSubmittable<(now: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + tips: { + /** + * Close and payout a tip. + * + * The dispatch origin for this call must be _Signed_. + * + * The tip identified by `hash` must have finished its countdown period. + * + * - `hash`: The identity of the open tip for which a tip value is declared. This is formed + * as the hash of the tuple of the original tip `reason` and the beneficiary account ID. + * + * # + * - Complexity: `O(T)` where `T` is the number of tippers. decoding `Tipper` vec of length + * `T`. `T` is charged as upper bound given by `ContainsLengthBound`. The actual cost + * depends on the implementation of `T::Tippers`. + * - DbReads: `Tips`, `Tippers`, `tip finder` + * - DbWrites: `Reasons`, `Tips`, `Tippers`, `tip finder` + * # + **/ + closeTip: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Report something `reason` that deserves a tip and claim any eventual the finder's fee. + * + * The dispatch origin for this call must be _Signed_. + * + * Payment: `TipReportDepositBase` will be reserved from the origin account, as well as + * `DataDepositPerByte` for each byte in `reason`. + * + * - `reason`: The reason for, or the thing that deserves, the tip; generally this will be + * a UTF-8-encoded URL. + * - `who`: The account which should be credited for the tip. + * + * Emits `NewTip` if successful. + * + * # + * - Complexity: `O(R)` where `R` length of `reason`. + * - encoding and hashing of 'reason' + * - DbReads: `Reasons`, `Tips` + * - DbWrites: `Reasons`, `Tips` + * # + **/ + reportAwesome: AugmentedSubmittable<(reason: Bytes | string | Uint8Array, who: AccountId32 | string | Uint8Array) => SubmittableExtrinsic, [Bytes, AccountId32]>; + /** + * Retract a prior tip-report from `report_awesome`, and cancel the process of tipping. + * + * If successful, the original deposit will be unreserved. + * + * The dispatch origin for this call must be _Signed_ and the tip identified by `hash` + * must have been reported by the signing account through `report_awesome` (and not + * through `tip_new`). + * + * - `hash`: The identity of the open tip for which a tip value is declared. This is formed + * as the hash of the tuple of the original tip `reason` and the beneficiary account ID. + * + * Emits `TipRetracted` if successful. + * + * # + * - Complexity: `O(1)` + * - Depends on the length of `T::Hash` which is fixed. + * - DbReads: `Tips`, `origin account` + * - DbWrites: `Reasons`, `Tips`, `origin account` + * # + **/ + retractTip: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Remove and slash an already-open tip. + * + * May only be called from `T::RejectOrigin`. + * + * As a result, the finder is slashed and the deposits are lost. + * + * Emits `TipSlashed` if successful. + * + * # + * `T` is charged as upper bound given by `ContainsLengthBound`. + * The actual cost depends on the implementation of `T::Tippers`. + * # + **/ + slashTip: AugmentedSubmittable<(hash: H256 | string | Uint8Array) => SubmittableExtrinsic, [H256]>; + /** + * Declare a tip value for an already-open tip. + * + * The dispatch origin for this call must be _Signed_ and the signing account must be a + * member of the `Tippers` set. + * + * - `hash`: The identity of the open tip for which a tip value is declared. This is formed + * as the hash of the tuple of the hash of the original tip `reason` and the beneficiary + * account ID. + * - `tip_value`: The amount of tip that the sender would like to give. The median tip + * value of active tippers will be given to the `who`. + * + * Emits `TipClosing` if the threshold of tippers has been reached and the countdown period + * has started. + * + * # + * - Complexity: `O(T)` where `T` is the number of tippers. decoding `Tipper` vec of length + * `T`, insert tip and check closing, `T` is charged as upper bound given by + * `ContainsLengthBound`. The actual cost depends on the implementation of `T::Tippers`. + * + * Actually weight could be lower as it depends on how many tips are in `OpenTip` but it + * is weighted as if almost full i.e of length `T-1`. + * - DbReads: `Tippers`, `Tips` + * - DbWrites: `Tips` + * # + **/ + tip: AugmentedSubmittable<(hash: H256 | string | Uint8Array, tipValue: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [H256, Compact]>; + /** + * Give a tip for something new; no finder's fee will be taken. + * + * The dispatch origin for this call must be _Signed_ and the signing account must be a + * member of the `Tippers` set. + * + * - `reason`: The reason for, or the thing that deserves, the tip; generally this will be + * a UTF-8-encoded URL. + * - `who`: The account which should be credited for the tip. + * - `tip_value`: The amount of tip that the sender would like to give. The median tip + * value of active tippers will be given to the `who`. + * + * Emits `NewTip` if successful. + * + * # + * - Complexity: `O(R + T)` where `R` length of `reason`, `T` is the number of tippers. + * - `O(T)`: decoding `Tipper` vec of length `T`. `T` is charged as upper bound given by + * `ContainsLengthBound`. The actual cost depends on the implementation of + * `T::Tippers`. + * - `O(R)`: hashing and encoding of reason of length `R` + * - DbReads: `Tippers`, `Reasons` + * - DbWrites: `Reasons`, `Tips` + * # + **/ + tipNew: AugmentedSubmittable<(reason: Bytes | string | Uint8Array, who: AccountId32 | string | Uint8Array, tipValue: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Bytes, AccountId32, Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + treasury: { + /** + * Approve a proposal. At a later time, the proposal will be allocated to the beneficiary + * and the original deposit will be returned. + * + * May only be called from `T::ApproveOrigin`. + * + * # + * - Complexity: O(1). + * - DbReads: `Proposals`, `Approvals` + * - DbWrite: `Approvals` + * # + **/ + approveProposal: AugmentedSubmittable<(proposalId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Put forward a suggestion for spending. A deposit proportional to the value + * is reserved and slashed if the proposal is rejected. It is returned once the + * proposal is awarded. + * + * # + * - Complexity: O(1) + * - DbReads: `ProposalCount`, `origin account` + * - DbWrites: `ProposalCount`, `Proposals`, `origin account` + * # + **/ + proposeSpend: AugmentedSubmittable<(value: Compact | AnyNumber | Uint8Array, beneficiary: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [Compact, MultiAddress]>; + /** + * Reject a proposed spend. The original deposit will be slashed. + * + * May only be called from `T::RejectOrigin`. + * + * # + * - Complexity: O(1) + * - DbReads: `Proposals`, `rejected proposer account` + * - DbWrites: `Proposals`, `rejected proposer account` + * # + **/ + rejectProposal: AugmentedSubmittable<(proposalId: Compact | AnyNumber | Uint8Array) => SubmittableExtrinsic, [Compact]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + ump: { + /** + * Service a single overweight upward message. + * + * - `origin`: Must pass `ExecuteOverweightOrigin`. + * - `index`: The index of the overweight message to service. + * - `weight_limit`: The amount of weight that message execution may take. + * + * Errors: + * - `UnknownMessageIndex`: Message of `index` is unknown. + * - `WeightOverLimit`: Message execution may use greater than `weight_limit`. + * + * Events: + * - `OverweightServiced`: On success. + **/ + serviceOverweight: AugmentedSubmittable<(index: u64 | AnyNumber | Uint8Array, weightLimit: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u64, u64]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + utility: { + /** + * 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_. + **/ + asDerivative: AugmentedSubmittable<(index: u16 | AnyNumber | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [u16, Call]>; + /** + * Send a batch of dispatch calls. + * + * May be called from any origin. + * + * - `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 call 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. + * # + * + * 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: AugmentedSubmittable<(calls: Vec | (Call | { callIndex?: any; args?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * 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. + * + * - `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 call 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. + * # + **/ + batchAll: AugmentedSubmittable<(calls: Vec | (Call | { callIndex?: any; args?: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Vec]>; + /** + * Dispatches a function call with a provided origin. + * + * The dispatch origin for this call must be _Root_. + * + * # + * - O(1). + * - Limited storage reads. + * - One DB write (event). + * - Weight of derivative `call` execution + T::WeightInfo::dispatch_as(). + * # + **/ + dispatchAs: AugmentedSubmittable<(asOrigin: PolkadotRuntimeOriginCaller | { system: any } | { Void: any } | { Council: any } | { TechnicalCommittee: any } | { ParachainsOrigin: any } | { XcmPallet: any } | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic, [PolkadotRuntimeOriginCaller, Call]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + vesting: { + /** + * Force a vested transfer. + * + * The dispatch origin for this call must be _Root_. + * + * - `source`: The account whose funds should be transferred. + * - `target`: The account that should be transferred the vested funds. + * - `schedule`: The vesting schedule attached to the transfer. + * + * Emits `VestingCreated`. + * + * NOTE: This will unlock all schedules through the current block. + * + * # + * - `O(1)`. + * - DbWeight: 4 Reads, 4 Writes + * - Reads: Vesting Storage, Balances Locks, Target Account, Source Account + * - Writes: Vesting Storage, Balances Locks, Target Account, Source Account + * # + **/ + forceVestedTransfer: AugmentedSubmittable<(source: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: PalletVestingVestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, MultiAddress, PalletVestingVestingInfo]>; + /** + * Merge two vesting schedules together, creating a new vesting schedule that unlocks over + * the highest possible start and end blocks. If both schedules have already started the + * current block will be used as the schedule start; with the caveat that if one schedule + * is finished by the current block, the other will be treated as the new merged schedule, + * unmodified. + * + * NOTE: If `schedule1_index == schedule2_index` this is a no-op. + * NOTE: This will unlock all schedules through the current block prior to merging. + * NOTE: If both schedules have ended by the current block, no new schedule will be created + * and both will be removed. + * + * Merged schedule attributes: + * - `starting_block`: `MAX(schedule1.starting_block, scheduled2.starting_block, + * current_block)`. + * - `ending_block`: `MAX(schedule1.ending_block, schedule2.ending_block)`. + * - `locked`: `schedule1.locked_at(current_block) + schedule2.locked_at(current_block)`. + * + * The dispatch origin for this call must be _Signed_. + * + * - `schedule1_index`: index of the first schedule to merge. + * - `schedule2_index`: index of the second schedule to merge. + **/ + mergeSchedules: AugmentedSubmittable<(schedule1Index: u32 | AnyNumber | Uint8Array, schedule2Index: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; + /** + * Unlock any vested funds of the sender account. + * + * The dispatch origin for this call must be _Signed_ and the sender must have funds still + * locked under this pallet. + * + * Emits either `VestingCompleted` or `VestingUpdated`. + * + * # + * - `O(1)`. + * - DbWeight: 2 Reads, 2 Writes + * - Reads: Vesting Storage, Balances Locks, [Sender Account] + * - Writes: Vesting Storage, Balances Locks, [Sender Account] + * # + **/ + vest: AugmentedSubmittable<() => SubmittableExtrinsic, []>; + /** + * Create a vested transfer. + * + * The dispatch origin for this call must be _Signed_. + * + * - `target`: The account receiving the vested funds. + * - `schedule`: The vesting schedule attached to the transfer. + * + * Emits `VestingCreated`. + * + * NOTE: This will unlock all schedules through the current block. + * + * # + * - `O(1)`. + * - DbWeight: 3 Reads, 3 Writes + * - Reads: Vesting Storage, Balances Locks, Target Account, [Sender Account] + * - Writes: Vesting Storage, Balances Locks, Target Account, [Sender Account] + * # + **/ + vestedTransfer: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, schedule: PalletVestingVestingInfo | { locked?: any; perBlock?: any; startingBlock?: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress, PalletVestingVestingInfo]>; + /** + * Unlock any vested funds of a `target` account. + * + * The dispatch origin for this call must be _Signed_. + * + * - `target`: The account whose vested funds should be unlocked. Must have funds still + * locked under this pallet. + * + * Emits either `VestingCompleted` or `VestingUpdated`. + * + * # + * - `O(1)`. + * - DbWeight: 3 Reads, 3 Writes + * - Reads: Vesting Storage, Balances Locks, Target Account + * - Writes: Vesting Storage, Balances Locks, Target Account + * # + **/ + vestOther: AugmentedSubmittable<(target: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [MultiAddress]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + xcmPallet: { + /** + * 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. + * + * NOTE: A successful return to this does *not* imply that the `msg` was executed successfully + * to completion; only that *some* of it was executed. + **/ + execute: AugmentedSubmittable<(message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array, maxWeight: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [XcmVersionedXcm, u64]>; + /** + * 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 Root. + * - `maybe_xcm_version`: The default XCM encoding version, or `None` to disable. + **/ + forceDefaultXcmVersion: AugmentedSubmittable<(maybeXcmVersion: Option | null | object | string | Uint8Array) => SubmittableExtrinsic, [Option]>; + /** + * Ask a location to notify us regarding their XCM version and any changes to it. + * + * - `origin`: Must be Root. + * - `location`: The location to which we should subscribe for XCM version notifications. + **/ + forceSubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation]>; + /** + * Require that a particular destination should no longer notify us regarding any XCM + * version changes. + * + * - `origin`: Must be Root. + * - `location`: The location to which we are currently subscribed for XCM version + * notifications which we no longer desire. + **/ + forceUnsubscribeVersionNotify: AugmentedSubmittable<(location: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation]>; + /** + * Extoll that a particular destination can be communicated with through a particular + * version of XCM. + * + * - `origin`: Must be Root. + * - `location`: The destination that is being described. + * - `xcm_version`: The latest version of XCM that `location` supports. + **/ + forceXcmVersion: AugmentedSubmittable<(location: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, xcmVersion: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [XcmV1MultiLocation, u32]>; + /** + * Transfer some assets from the local chain to the sovereign account of a destination chain and forward + * a notification XCM. + * + * Fee payment on the destination side is made from the first asset listed in the `assets` vector. + * + * - `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` side. + * - `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. + **/ + limitedReserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>; + /** + * Teleport some assets from the local chain to some destination chain. + * + * Fee payment on the destination side is made from the first asset listed in the `assets` vector. + * + * - `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. The first item should be the currency used to to pay the fee on the + * `dest` side. May not be empty. + * - `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. + **/ + limitedTeleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array, weightLimit: XcmV2WeightLimit | { Unlimited: any } | { Limited: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32, XcmV2WeightLimit]>; + /** + * Transfer some assets from the local chain to the sovereign account of a destination chain and forward + * a notification XCM. + * + * Fee payment on the destination side is made from the first asset listed in the `assets` vector and + * fee-weight is calculated locally and thus remote weights are assumed to be equal to + * local weights. + * + * - `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` side. + * - `fee_asset_item`: The index into `assets` of the item which should be used to pay + * fees. + **/ + reserveTransferAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>; + send: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, message: XcmVersionedXcm | { V0: any } | { V1: any } | { V2: any } | string | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedXcm]>; + /** + * Teleport some assets from the local chain to some destination chain. + * + * Fee payment on the destination side is made from the first asset listed in the `assets` vector and + * fee-weight is calculated locally and thus remote weights are assumed to be equal to + * local weights. + * + * - `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. The first item should be the currency used to to pay the fee on the + * `dest` side. May not be empty. + * - `fee_asset_item`: The index into `assets` of the item which should be used to pay + * fees. + **/ + teleportAssets: AugmentedSubmittable<(dest: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, beneficiary: XcmVersionedMultiLocation | { V0: any } | { V1: any } | string | Uint8Array, assets: XcmVersionedMultiAssets | { V0: any } | { V1: any } | string | Uint8Array, feeAssetItem: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [XcmVersionedMultiLocation, XcmVersionedMultiLocation, XcmVersionedMultiAssets, u32]>; + /** + * Generic tx + **/ + [key: string]: SubmittableExtrinsicFunction; + }; + } // AugmentedSubmittables +} // declare module diff --git a/packages/api-augment/src/augment/consts.ts b/packages/api-augment/src/substrate/consts.ts similarity index 100% rename from packages/api-augment/src/augment/consts.ts rename to packages/api-augment/src/substrate/consts.ts diff --git a/packages/api-augment/src/augment/errors.ts b/packages/api-augment/src/substrate/errors.ts similarity index 100% rename from packages/api-augment/src/augment/errors.ts rename to packages/api-augment/src/substrate/errors.ts diff --git a/packages/api-augment/src/augment/events.ts b/packages/api-augment/src/substrate/events.ts similarity index 100% rename from packages/api-augment/src/augment/events.ts rename to packages/api-augment/src/substrate/events.ts diff --git a/packages/api-augment/src/substrate/index.ts b/packages/api-augment/src/substrate/index.ts new file mode 100644 index 0000000000..54df49bcd9 --- /dev/null +++ b/packages/api-augment/src/substrate/index.ts @@ -0,0 +1,9 @@ +// Copyright 2017-2021 @polkadot/api-augment authors & contributors +// SPDX-License-Identifier: Apache-2.0 + +import '../base'; +import './consts'; +import './errors'; +import './events'; +import './query'; +import './tx'; diff --git a/packages/api-augment/src/augment/query.ts b/packages/api-augment/src/substrate/query.ts similarity index 100% rename from packages/api-augment/src/augment/query.ts rename to packages/api-augment/src/substrate/query.ts diff --git a/packages/api-augment/src/augment/tx.ts b/packages/api-augment/src/substrate/tx.ts similarity index 100% rename from packages/api-augment/src/augment/tx.ts rename to packages/api-augment/src/substrate/tx.ts diff --git a/packages/api-augment/tsconfig.json b/packages/api-augment/tsconfig.json index 54ec3181dd..3aa72c95e1 100644 --- a/packages/api-augment/tsconfig.json +++ b/packages/api-augment/tsconfig.json @@ -5,6 +5,10 @@ "outDir": "./build", "rootDir": "./src" }, + "exclude": [ + "**/kusama/*.ts", + "**/polkadot/*.ts" + ], "references": [ { "path": "../api-base" }, { "path": "../rpc-augment" }, diff --git a/packages/api-augment/tsconfig.kusama.json b/packages/api-augment/tsconfig.kusama.json new file mode 100644 index 0000000000..a0220ecb3b --- /dev/null +++ b/packages/api-augment/tsconfig.kusama.json @@ -0,0 +1,19 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "baseUrl": "..", + "outDir": "./build", + "rootDir": "./src" + }, + "include": [ + "**/base.ts", + "**/kusama/*.ts" + ], + "references": [ + { "path": "../api-base" }, + { "path": "../rpc-augment" }, + { "path": "../types" }, + { "path": "../types-codec" }, + { "path": "../types-augment" } + ] +} diff --git a/packages/api-augment/tsconfig.polkadot.json b/packages/api-augment/tsconfig.polkadot.json new file mode 100644 index 0000000000..aeafe71495 --- /dev/null +++ b/packages/api-augment/tsconfig.polkadot.json @@ -0,0 +1,19 @@ +{ + "extends": "../../tsconfig.base.json", + "compilerOptions": { + "baseUrl": "..", + "outDir": "./build", + "rootDir": "./src" + }, + "include": [ + "**/base.ts", + "**/polkadot/*.ts" + ], + "references": [ + { "path": "../api-base" }, + { "path": "../rpc-augment" }, + { "path": "../types" }, + { "path": "../types-codec" }, + { "path": "../types-augment" } + ] +} diff --git a/packages/typegen/package.json b/packages/typegen/package.json index 8ef43df0c9..4c19bbd795 100644 --- a/packages/typegen/package.json +++ b/packages/typegen/package.json @@ -48,7 +48,7 @@ "@polkadot/x-ws": "^8.2.2", "handlebars": "^4.7.7", "websocket": "^1.0.34", - "yargs": "^17.3.0" + "yargs": "^17.3.1" }, "devDependencies": { "@types/websocket": "^1.0.4", diff --git a/packages/typegen/src/generate/consts.ts b/packages/typegen/src/generate/consts.ts index d5bf4b96c0..84d195d582 100644 --- a/packages/typegen/src/generate/consts.ts +++ b/packages/typegen/src/generate/consts.ts @@ -85,7 +85,7 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, // Call `generateForMeta()` with current static metadata /** @internal */ -export function generateDefaultConsts (dest = 'packages/api-augment/src/augment/consts.ts', data?: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void { +export function generateDefaultConsts (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void { const { metadata } = initMeta(data, extraTypes); return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions); diff --git a/packages/typegen/src/generate/errors.ts b/packages/typegen/src/generate/errors.ts index b9d5e494b7..6676a6932b 100644 --- a/packages/typegen/src/generate/errors.ts +++ b/packages/typegen/src/generate/errors.ts @@ -48,7 +48,7 @@ function generateForMeta (meta: Metadata, dest: string, isStrict: boolean): void // Call `generateForMeta()` with current static metadata /** @internal */ -export function generateDefaultErrors (dest = 'packages/api-augment/src/augment/errors.ts', data?: HexString, extraTypes: ExtraTypes = {}, isStrict = false): void { +export function generateDefaultErrors (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false): void { const { metadata } = initMeta(data, extraTypes); return generateForMeta(metadata, dest, isStrict); diff --git a/packages/typegen/src/generate/events.ts b/packages/typegen/src/generate/events.ts index 3a7bca0a0d..3ef8ec6932 100644 --- a/packages/typegen/src/generate/events.ts +++ b/packages/typegen/src/generate/events.ts @@ -77,7 +77,7 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, // Call `generateForMeta()` with current static metadata /** @internal */ -export function generateDefaultEvents (dest = 'packages/api-augment/src/augment/events.ts', data?: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void { +export function generateDefaultEvents (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void { const { metadata } = initMeta(data, extraTypes); return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions); diff --git a/packages/typegen/src/generate/query.ts b/packages/typegen/src/generate/query.ts index 0ab86d8085..d84a850136 100644 --- a/packages/typegen/src/generate/query.ts +++ b/packages/typegen/src/generate/query.ts @@ -134,7 +134,7 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr // Call `generateForMeta()` with current static metadata /** @internal */ -export function generateDefaultQuery (dest = 'packages/api-augment/src/augment/query.ts', data?: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void { +export function generateDefaultQuery (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void { const { metadata, registry } = initMeta(data, extraTypes); return generateForMeta(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions); diff --git a/packages/typegen/src/generate/rpc.ts b/packages/typegen/src/generate/rpc.ts index dd16d95e42..38622b8f15 100644 --- a/packages/typegen/src/generate/rpc.ts +++ b/packages/typegen/src/generate/rpc.ts @@ -8,6 +8,7 @@ import type { ExtraTypes } from './types'; import Handlebars from 'handlebars'; import * as defaultDefinitions from '@polkadot/types/interfaces/definitions'; +import staticSubstrate from '@polkadot/types-support/metadata/static-substrate'; import { createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util'; @@ -144,7 +145,7 @@ export function generateRpcTypes (registry: TypeRegistry, importDefinitions: Rec } export function generateDefaultRpc (dest = 'packages/rpc-augment/src/augment/jsonrpc.ts', extraTypes: ExtraTypes = {}): void { - const { registry } = initMeta(undefined, extraTypes); + const { registry } = initMeta(staticSubstrate, extraTypes); generateRpcTypes( registry, diff --git a/packages/typegen/src/generate/tx.ts b/packages/typegen/src/generate/tx.ts index aa66bbae4c..21f67df475 100644 --- a/packages/typegen/src/generate/tx.ts +++ b/packages/typegen/src/generate/tx.ts @@ -119,7 +119,7 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr // Call `generateForMeta()` with current static metadata /** @internal */ -export function generateDefaultTx (dest = 'packages/api-augment/src/augment/tx.ts', data?: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void { +export function generateDefaultTx (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void { const { metadata, registry } = initMeta(data, extraTypes); return generateForMeta(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions); diff --git a/packages/typegen/src/interfacesTs.ts b/packages/typegen/src/interfacesTs.ts index 310a2706ab..700a569ad7 100644 --- a/packages/typegen/src/interfacesTs.ts +++ b/packages/typegen/src/interfacesTs.ts @@ -1,18 +1,31 @@ // Copyright 2017-2021 @polkadot/typegen authors & contributors // SPDX-License-Identifier: Apache-2.0 +import type { HexString } from '@polkadot/util/types'; + +import kusama from '@polkadot/types-support/metadata/static-kusama'; +import polkadot from '@polkadot/types-support/metadata/static-polkadot'; +import substrate from '@polkadot/types-support/metadata/static-substrate'; + import { generateDefaultConsts, generateDefaultErrors, generateDefaultEvents, generateDefaultInterface, generateDefaultLookup, generateDefaultQuery, generateDefaultRpc, generateDefaultTsDef, generateDefaultTx } from './generate'; +const BASE = 'packages/api-augment/src'; +const METAS = Object.entries({ kusama, polkadot, substrate }) as [string, HexString][]; + export function main (): void { generateDefaultLookup(); generateDefaultInterface(); - - generateDefaultConsts(); - generateDefaultErrors(); - generateDefaultEvents(); - generateDefaultQuery(); - generateDefaultTx(); generateDefaultRpc(); - generateDefaultTsDef(); + + for (const [name, staticMeta] of METAS) { + console.log(); + console.log(`*** Generating for ${name}`); + + generateDefaultConsts(`${BASE}/${name}/consts.ts`, staticMeta); + generateDefaultErrors(`${BASE}/${name}/errors.ts`, staticMeta); + generateDefaultEvents(`${BASE}/${name}/events.ts`, staticMeta); + generateDefaultQuery(`${BASE}/${name}/query.ts`, staticMeta); + generateDefaultTx(`${BASE}/${name}/tx.ts`, staticMeta); + } } diff --git a/packages/typegen/src/util/initMeta.ts b/packages/typegen/src/util/initMeta.ts index 01beac3e70..3094d8ee39 100644 --- a/packages/typegen/src/util/initMeta.ts +++ b/packages/typegen/src/util/initMeta.ts @@ -5,7 +5,6 @@ import type { HexString } from '@polkadot/util/types'; import type { ExtraTypes } from '../generate/types'; import { Metadata, TypeRegistry } from '@polkadot/types'; -import staticSubstrate from '@polkadot/types-support/metadata/static-substrate'; import { registerDefinitions } from './register'; @@ -14,7 +13,7 @@ interface Result { registry: TypeRegistry; } -export function initMeta (staticMeta: HexString = staticSubstrate, extraTypes: ExtraTypes = {}): Result { +export function initMeta (staticMeta: HexString, extraTypes: ExtraTypes = {}): Result { const registry = new TypeRegistry(); registerDefinitions(registry, extraTypes); diff --git a/tsconfig.json b/tsconfig.json index 356a529f6a..bd7ad3cd53 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -7,6 +7,8 @@ { "path": "./packages/api" }, { "path": "./packages/api/tsconfig.spec.json" }, { "path": "./packages/api-augment" }, + { "path": "./packages/api-augment/tsconfig.kusama.json" }, + { "path": "./packages/api-augment/tsconfig.polkadot.json" }, { "path": "./packages/api-base" }, { "path": "./packages/api-contract" }, { "path": "./packages/api-contract/tsconfig.spec.json" }, diff --git a/yarn.lock b/yarn.lock index 09d5b5bc2b..c50dd5b418 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1955,9 +1955,9 @@ __metadata: languageName: unknown linkType: soft -"@polkadot/dev@npm:^0.64.18": - version: 0.64.18 - resolution: "@polkadot/dev@npm:0.64.18" +"@polkadot/dev@npm:^0.64.19": + version: 0.64.19 + resolution: "@polkadot/dev@npm:0.64.19" dependencies: "@babel/cli": ^7.16.0 "@babel/core": ^7.16.5 @@ -1998,7 +1998,7 @@ __metadata: eslint-plugin-import-newlines: ^1.1.7 eslint-plugin-node: ^11.1.0 eslint-plugin-promise: ^6.0.0 - eslint-plugin-react: ^7.27.1 + eslint-plugin-react: ^7.28.0 eslint-plugin-react-hooks: ^4.3.0 eslint-plugin-simple-import-sort: ^7.0.0 eslint-plugin-sort-destructure-keys: ^1.4.0 @@ -2020,7 +2020,7 @@ __metadata: rollup: ^2.61.1 rollup-plugin-cleanup: ^3.2.1 typescript: ^4.5.4 - yargs: ^17.3.0 + yargs: ^17.3.1 bin: polkadot-ci-ghact-build: scripts/polkadot-ci-ghact-build.mjs polkadot-ci-ghact-docs: scripts/polkadot-ci-ghact-docs.mjs @@ -2042,7 +2042,7 @@ __metadata: polkadot-exec-rollup: scripts/polkadot-exec-rollup.mjs polkadot-exec-tsc: scripts/polkadot-exec-tsc.mjs polkadot-exec-webpack: scripts/polkadot-exec-webpack.mjs - checksum: 9e5fc2c65bf2132422e103caa34c194b6c6d731997200cb72893634be3c1656a16f27a698c316ead92984470eaecc301594043b21a8aad270e5678983d7953f1 + checksum: 4a1fa23d0f54f5901761ec0819f337d180b81ac481a20e57ec20086bc6f12810c60cda06ab5b2802f36c2ad952b51a36fe20a4f293cfda2427fb668cc9aa91da languageName: node linkType: hard @@ -2147,7 +2147,7 @@ __metadata: "@types/yargs": ^17.0.8 handlebars: ^4.7.7 websocket: ^1.0.34 - yargs: ^17.3.0 + yargs: ^17.3.1 bin: polkadot-types-chain-info: ./scripts/polkadot-types-chain-info.cjs polkadot-types-from-chain: ./scripts/polkadot-types-from-chain.cjs @@ -4806,9 +4806,9 @@ __metadata: languageName: node linkType: hard -"eslint-plugin-react@npm:^7.27.1": - version: 7.27.1 - resolution: "eslint-plugin-react@npm:7.27.1" +"eslint-plugin-react@npm:^7.28.0": + version: 7.28.0 + resolution: "eslint-plugin-react@npm:7.28.0" dependencies: array-includes: ^3.1.4 array.prototype.flatmap: ^1.2.5 @@ -4826,7 +4826,7 @@ __metadata: string.prototype.matchall: ^4.0.6 peerDependencies: eslint: ^3 || ^4 || ^5 || ^6 || ^7 || ^8 - checksum: db1ce303b597ede0bc8873d3f575b05873b06a058162c80f76604c9096eee8f72f299d7f849a86ac2e59f269c196575e6bcfb1ef9d7cbb23f533d081bcc15ea0 + checksum: 90293d0fd53bb1f735ffd32141cdd211fb1120c9f7bbe5342f9e923261a39e52a2b2575d4e46c9cd77d257f42db4a99b8b339689fc5b5c1c26048929f69b1784 languageName: node linkType: hard @@ -9018,7 +9018,7 @@ resolve@^2.0.0-next.3: "@babel/core": ^7.16.5 "@babel/register": ^7.16.5 "@babel/runtime": ^7.16.5 - "@polkadot/dev": ^0.64.18 + "@polkadot/dev": ^0.64.19 "@polkadot/ts": ^0.4.22 "@polkadot/typegen": "workspace:packages/typegen" "@types/jest": ^27.0.3 @@ -10478,9 +10478,9 @@ resolve@^2.0.0-next.3: languageName: node linkType: hard -"yargs@npm:^17.0.0, yargs@npm:^17.3.0": - version: 17.3.0 - resolution: "yargs@npm:17.3.0" +"yargs@npm:^17.0.0, yargs@npm:^17.3.1": + version: 17.3.1 + resolution: "yargs@npm:17.3.1" dependencies: cliui: ^7.0.2 escalade: ^3.1.1 @@ -10489,6 +10489,6 @@ resolve@^2.0.0-next.3: string-width: ^4.2.3 y18n: ^5.0.5 yargs-parser: ^21.0.0 - checksum: 2b687338684bf9645e9389ffdbe813fc5a2ddfede299d46fbe5ac80eb9a391e558b97861ba44d2256936ebe9d7f8135f6a38af1c76a5685eac4061008b2df57a + checksum: 64fc2e32c56739f1d14d2d24acd17a6944c3c8e3e3558f09fc1953ac112e868cc16013d282886b9d5be22187f8b9ed4f60741a6b1011f595ce2718805a656852 languageName: node linkType: hard