@polkadot/api-augment 7.0.3-8 → 7.1.2-1

package/kusama/consts.d.ts

@@ -0,0 +1,892 @@
+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' {
+    interface AugmentedConsts<ApiType extends ApiTypes> {
+        auctions: {
+            /**
+             * The number of blocks over which an auction may be retroactively ended.
+             **/
+            endingPeriod: u32 & AugmentedConst<ApiType>;
+            leasePeriodsPerSlot: u32 & AugmentedConst<ApiType>;
+            /**
+             * The length of each sample to take during the ending period.
+             *
+             * `EndingPeriod` / `SampleLength` = Total # of Samples
+             **/
+            sampleLength: u32 & AugmentedConst<ApiType>;
+            slotRangeCount: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Max number of authorities allowed
+             **/
+            maxAuthorities: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<u64> & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        balances: {
+            /**
+             * The minimum amount required to keep an account open.
+             **/
+            existentialDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of locks that should exist on an account.
+             * Not strictly enforced, but used for weight estimation.
+             **/
+            maxLocks: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of named reserves that can exist on an account.
+             **/
+            maxReserves: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        bounties: {
+            /**
+             * Percentage of the curator fee that will be reserved upfront as deposit for bounty
+             * curator.
+             **/
+            bountyCuratorDeposit: Permill & AugmentedConst<ApiType>;
+            /**
+             * The amount held on deposit for placing a bounty proposal.
+             **/
+            bountyDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * The delay period for which a bounty beneficiary need to wait before claim the payout.
+             **/
+            bountyDepositPayoutDelay: u32 & AugmentedConst<ApiType>;
+            /**
+             * Bounty duration in blocks.
+             **/
+            bountyUpdatePeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Minimum value for a bounty.
+             **/
+            bountyValueMinimum: u128 & AugmentedConst<ApiType>;
+            /**
+             * The amount held on deposit per byte within the tip report reason or bounty description.
+             **/
+            dataDepositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * Maximum acceptable reason length.
+             *
+             * Benchmarks depend on this value, be sure to update weights file when changing this value
+             **/
+            maximumReasonLength: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        claims: {
+            prefix: Bytes & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * `PalletId` for the crowdloan pallet. An appropriate value could be `PalletId(*b"py/cfund")`
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * Max number of storage keys to remove per extrinsic call.
+             **/
+            removeKeysLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        democracy: {
+            /**
+             * Period in blocks where an external proposal may not be re-submitted after being vetoed.
+             **/
+            cooloffPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Minimum voting period allowed for a fast-track referendum.
+             **/
+            fastTrackVotingPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * How often (in blocks) new public referenda are launched.
+             **/
+            launchPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of public proposals that can exist at any time.
+             **/
+            maxProposals: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * The minimum amount to be used as a deposit for a public referendum proposal.
+             **/
+            minimumDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The amount of balance that must be deposited per byte of preimage stored.
+             **/
+            preimageByteDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * How often (in blocks) to check for new votes.
+             **/
+            votingPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * The priority of the unsigned transaction submitted in the unsigned-phase
+             **/
+            minerTxPriority: u64 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Base deposit for a signed solution.
+             **/
+            signedDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * Per-byte deposit for a signed solution.
+             **/
+            signedDepositByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * Per-weight deposit for a signed solution.
+             **/
+            signedDepositWeight: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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<T>` 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<ApiType>;
+            /**
+             * Maximum weight of a signed solution.
+             *
+             * This should probably be similar to [`Config::MinerMaxWeight`].
+             **/
+            signedMaxWeight: u64 & AugmentedConst<ApiType>;
+            /**
+             * Duration of the signed phase.
+             **/
+            signedPhase: u32 & AugmentedConst<ApiType>;
+            /**
+             * Base reward for a signed solution
+             **/
+            signedRewardBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * The minimum amount of improvement to the solution score that defines a solution as
+             * "better" (in any phase).
+             **/
+            solutionImprovementThreshold: Perbill & AugmentedConst<ApiType>;
+            /**
+             * Duration of the unsigned phase.
+             **/
+            unsignedPhase: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Maximum number of items that may be in each duration queue.
+             **/
+            maxQueueLen: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Number of duration queues in total. This sets the maximum duration supported, which is
+             * this value multiplied by `Period`.
+             **/
+            queueCount: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        grandpa: {
+            /**
+             * Max Authorities in use
+             **/
+            maxAuthorities: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        identity: {
+            /**
+             * The amount held on deposit for a registered identity
+             **/
+            basicDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The amount held on deposit per additional field for a registered identity.
+             **/
+            fieldDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Maxmimum number of registrars allowed in the system. Needed to bound the complexity
+             * of, e.g., updating judgements.
+             **/
+            maxRegistrars: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of sub-accounts allowed per identified account.
+             **/
+            maxSubAccounts: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        indices: {
+            /**
+             * The deposit needed for reserving an index.
+             **/
+            deposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * The maximum amount of signatories allowed in the multisig.
+             **/
+            maxSignatories: u16 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        paras: {
+            unsignedPriority: u64 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        phragmenElection: {
+            /**
+             * How much should be locked up in order to submit one's candidacy.
+             **/
+            candidacyBond: u128 & AugmentedConst<ApiType>;
+            /**
+             * Number of members to elect.
+             **/
+            desiredMembers: u32 & AugmentedConst<ApiType>;
+            /**
+             * Number of runners_up to keep.
+             **/
+            desiredRunnersUp: u32 & AugmentedConst<ApiType>;
+            /**
+             * Identifier for the elections-phragmen pallet's lock
+             **/
+            palletId: U8aFixed & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * The amount of bond that need to be locked for each vote (32 bytes).
+             **/
+            votingBondFactor: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * The maximum amount of time-delayed announcements that are allowed to be pending.
+             **/
+            maxPending: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum amount of proxies allowed for a single account.
+             **/
+            maxProxies: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * The maximum amount of friends allowed in a recovery configuration.
+             **/
+            maxFriends: u16 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        registrar: {
+            /**
+             * The deposit to be paid per byte stored on chain.
+             **/
+            dataDepositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * The maximum number of scheduled calls in the queue for a single block.
+             * Not strictly enforced, but used for weight estimation.
+             **/
+            maxScheduledPerBlock: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        slots: {
+            /**
+             * The number of blocks to offset each lease period by.
+             **/
+            leaseOffset: u32 & AugmentedConst<ApiType>;
+            /**
+             * The number of blocks over which a single period lasts.
+             **/
+            leasePeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        society: {
+            /**
+             * The minimum amount of a deposit required for a bid to be made.
+             **/
+            candidateDeposit: u128 & AugmentedConst<ApiType>;
+            /**
+             * The number of blocks between membership challenges.
+             **/
+            challengePeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of candidates that we accept per round.
+             **/
+            maxCandidateIntake: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum duration of the payout lock.
+             **/
+            maxLockDuration: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * The societies's pallet id
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * The amount of incentive paid within each period. Doesn't include VoterTip.
+             **/
+            periodSpend: u128 & AugmentedConst<ApiType>;
+            /**
+             * The number of blocks between candidate/membership rotation periods.
+             **/
+            rotationPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        staking: {
+            /**
+             * Number of eras that staked funds must remain bonded for.
+             **/
+            bondingDuration: u32 & AugmentedConst<ApiType>;
+            maxNominations: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Number of sessions per era.
+             **/
+            sessionsPerEra: u32 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        system: {
+            /**
+             * Maximum number of block number to block hash mappings to keep (oldest pruned first).
+             **/
+            blockHashCount: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum length of a block (in bytes).
+             **/
+            blockLength: FrameSystemLimitsBlockLength & AugmentedConst<ApiType>;
+            /**
+             * Block & extrinsics weights: base values and limits.
+             **/
+            blockWeights: FrameSystemLimitsBlockWeights & AugmentedConst<ApiType>;
+            /**
+             * The weight of runtime database operations the runtime can invoke.
+             **/
+            dbWeight: FrameSupportWeightsRuntimeDbWeight & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Get the chain's current version.
+             **/
+            version: SpVersionRuntimeVersion & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        tips: {
+            /**
+             * The amount held on deposit per byte within the tip report reason or bounty description.
+             **/
+            dataDepositPerByte: u128 & AugmentedConst<ApiType>;
+            /**
+             * Maximum acceptable reason length.
+             *
+             * Benchmarks depend on this value, be sure to update weights file when changing this value
+             **/
+            maximumReasonLength: u32 & AugmentedConst<ApiType>;
+            /**
+             * The period for which a tip remains open after is has achieved threshold tippers.
+             **/
+            tipCountdown: u32 & AugmentedConst<ApiType>;
+            /**
+             * The percent of the final tip which goes to the original reporter of the tip.
+             **/
+            tipFindersFee: Percent & AugmentedConst<ApiType>;
+            /**
+             * The amount held on deposit for placing a tip report.
+             **/
+            tipReportDepositBase: u128 & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * The fee to be paid for making a transaction; the per-byte portion.
+             **/
+            transactionByteFee: u128 & AugmentedConst<ApiType>;
+            /**
+             * The polynomial that is applied in order to derive fee from weight.
+             **/
+            weightToFee: Vec<FrameSupportWeightsWeightToFeeCoefficient> & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        treasury: {
+            /**
+             * Percentage of spare funds (if any) that are burnt per spend period.
+             **/
+            burn: Permill & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of approvals that can wait in the spending queue.
+             **/
+            maxApprovals: u32 & AugmentedConst<ApiType>;
+            /**
+             * The treasury's pallet id, used for deriving its sovereign account ID.
+             **/
+            palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+            /**
+             * 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<ApiType>;
+            /**
+             * Minimum amount of funds that should be placed in a deposit for making a proposal.
+             **/
+            proposalBondMinimum: u128 & AugmentedConst<ApiType>;
+            /**
+             * Period between successive spends.
+             **/
+            spendPeriod: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        utility: {
+            /**
+             * The limit on the number of batched calls.
+             **/
+            batchedCallsLimit: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+        vesting: {
+            maxVestingSchedules: u32 & AugmentedConst<ApiType>;
+            /**
+             * The minimum amount transferred to call `vested_transfer`.
+             **/
+            minVestedTransfer: u128 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+    }
+}