import '@polkadot/api-base/types/consts'; import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types'; import type { Bytes, Option, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; import type { Codec, ITuple } from '@polkadot/types-codec/types'; import type { AccountId32, Perbill, Percent, Permill, Perquintill } from '@polkadot/types/interfaces/runtime'; import type { FrameSupportPalletId, FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, PalletContractsEnvironment, PalletContractsSchedule, PalletReferendaTrackDetails, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, SpWeightsWeightV2Weight } from '@polkadot/types/lookup'; export type __AugmentedConst = AugmentedConst; declare module '@polkadot/api-base/types/consts' { interface AugmentedConsts { alliance: { /** * The deposit required for submitting candidacy. **/ allyDeposit: u128 & AugmentedConst; /** * The maximum number of announcements. **/ maxAnnouncementsCount: u32 & AugmentedConst; /** * The maximum number of members per member role. **/ maxMembersCount: u32 & AugmentedConst; /** * The maximum number of the unscrupulous items supported by the pallet. **/ maxUnscrupulousItems: u32 & AugmentedConst; /** * The maximum length of a website URL. **/ maxWebsiteUrlLength: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; allianceMotion: { /** * The maximum weight of a dispatch call that can be proposed and executed. **/ maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; assetConversion: { /** * A fee to withdraw the liquidity. **/ liquidityWithdrawalFee: Permill & AugmentedConst; /** * A % the liquidity providers will take of every swap. Represents 10ths of a percent. **/ lpFee: u32 & AugmentedConst; /** * The max number of hops in a swap. **/ maxSwapPathLength: u32 & AugmentedConst; /** * The minimum LP token amount that could be minted. Ameliorates rounding errors. **/ mintMinLiquidity: u128 & AugmentedConst; /** * The pallet's id, used for deriving its sovereign account ID. **/ palletId: FrameSupportPalletId & AugmentedConst; /** * A one-time fee to setup the pool. **/ poolSetupFee: u128 & AugmentedConst; /** * Asset class from [`Config::Assets`] used to pay the [`Config::PoolSetupFee`]. **/ poolSetupFeeAsset: FrameSupportTokensFungibleUnionOfNativeOrWithId & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; assetRewards: { /** * The pallet's unique identifier, used to derive the pool's account ID. * * The account ID is derived once during pool creation and stored in the storage. **/ palletId: FrameSupportPalletId & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; assets: { /** * The amount of funds that must be reserved when creating a new approval. **/ approvalDeposit: u128 & AugmentedConst; /** * The amount of funds that must be reserved for a non-provider asset account to be * maintained. **/ assetAccountDeposit: u128 & AugmentedConst; /** * The basic amount of funds that must be reserved for an asset. **/ assetDeposit: u128 & AugmentedConst; /** * The basic amount of funds that must be reserved when adding metadata to your asset. **/ metadataDepositBase: u128 & AugmentedConst; /** * The additional funds that must be reserved for the number of bytes you store in your * metadata. **/ metadataDepositPerByte: u128 & AugmentedConst; /** * Max number of items to destroy per `destroy_accounts` and `destroy_approvals` call. * * Must be configured to result in a weight that makes each call fit in a block. **/ removeItemsLimit: u32 & AugmentedConst; /** * The maximum length of a name or symbol stored on-chain. **/ stringLimit: 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; /** * The maximum number of nominators for each validator. **/ maxNominators: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; balances: { /** * The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO! * * If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for * this pallet. However, you do so at your own risk: this will open up a major DoS vector. * In case you have multiple sources of provider references, you may also get unexpected * behaviour if you set this to zero. * * Bottom line: Do yourself a favour and make it at least one! **/ existentialDeposit: u128 & AugmentedConst; /** * The maximum number of individual freeze locks that can exist on an account at any time. **/ maxFreezes: u32 & AugmentedConst; /** * The maximum number of locks that should exist on an account. * Not strictly enforced, but used for weight estimation. * * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/` **/ maxLocks: u32 & AugmentedConst; /** * The maximum number of named reserves that can exist on an account. * * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/` **/ maxReserves: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; beefy: { /** * The maximum number of authorities that can be added. **/ maxAuthorities: u32 & AugmentedConst; /** * The maximum number of nominators for each validator. **/ maxNominators: u32 & AugmentedConst; /** * The maximum number of entries to keep in the set id to session index mapping. * * Since the `SetIdSession` map is only used for validating equivocations this * value should relate to the bonding duration of whatever staking system is * being used (if any). If equivocation handling is not enabled then this value * can be zero. **/ maxSetIdSessionEntries: u64 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; bounties: { /** * 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; /** * The time limit for a curator to act before a bounty expires. * * The period that starts when a curator is approved, during which they must execute or * update the bounty via `extend_bounty_expiry`. If missed, the bounty expires, and the * curator may be slashed. If `BlockNumberFor::MAX`, bounties stay active indefinitely, * removing the need for `extend_bounty_expiry`. **/ bountyUpdatePeriod: u32 & AugmentedConst; /** * Minimum value for a bounty. **/ bountyValueMinimum: u128 & AugmentedConst; /** * Maximum amount of funds that should be placed in a deposit for making a proposal. **/ curatorDepositMax: Option & AugmentedConst; /** * Minimum amount of funds that should be placed in a deposit for making a proposal. **/ curatorDepositMin: Option & AugmentedConst; /** * The curator deposit is calculated as a percentage of the curator fee. * * This deposit has optional upper and lower bounds with `CuratorDepositMax` and * `CuratorDepositMin`. **/ curatorDepositMultiplier: Permill & 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; }; broker: { /** * Given that we are performing all auto-renewals in a single block, it has to be limited. **/ maxAutoRenewals: u32 & AugmentedConst; /** * Maximum number of legacy leases. **/ maxLeasedCores: u32 & AugmentedConst; /** * Maximum number of system cores. **/ maxReservedCores: u32 & AugmentedConst; /** * The smallest amount of credits a user can purchase. * * Needed to prevent spam attacks. **/ minimumCreditPurchase: u128 & AugmentedConst; /** * Identifier from which the internal Pot is generated. **/ palletId: FrameSupportPalletId & AugmentedConst; /** * Number of Relay-chain blocks per timeslice. **/ timeslicePeriod: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; childBounties: { /** * Minimum value for a child-bounty. **/ childBountyValueMinimum: u128 & AugmentedConst; /** * Maximum number of child bounties that can be added to a parent bounty. **/ maxActiveChildBountyCount: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; contracts: { /** * The version of the HostFn APIs that are available in the runtime. * * Only valid value is `()`. **/ apiVersion: u16 & AugmentedConst; /** * The percentage of the storage deposit that should be held for using a code hash. * Instantiating a contract, or calling [`chain_extension::Ext::lock_delegate_dependency`] * protects the code from being removed. In order to prevent abuse these actions are * protected with a percentage of the code deposit. **/ codeHashLockupDepositPercent: Perbill & AugmentedConst; /** * Fallback value to limit the storage deposit if it's not being set by the caller. **/ defaultDepositLimit: u128 & AugmentedConst; /** * The amount of balance a caller has to pay for each byte of storage. * * # Note * * Changing this value for an existing chain might need a storage migration. **/ depositPerByte: u128 & AugmentedConst; /** * The amount of balance a caller has to pay for each storage item. * * # Note * * Changing this value for an existing chain might need a storage migration. **/ depositPerItem: u128 & AugmentedConst; /** * Type that bundles together all the runtime configurable interface types. * * This is not a real config. We just mention the type here as constant so that * its type appears in the metadata. Only valid value is `()`. **/ environment: PalletContractsEnvironment & AugmentedConst; /** * The maximum length of a contract code in bytes. * * The value should be chosen carefully taking into the account the overall memory limit * your runtime has, as well as the [maximum allowed callstack * depth](#associatedtype.CallStack). Look into the `integrity_test()` for some insights. **/ maxCodeLen: u32 & AugmentedConst; /** * The maximum length of the debug buffer in bytes. **/ maxDebugBufferLen: u32 & AugmentedConst; /** * The maximum number of delegate_dependencies that a contract can lock with * [`chain_extension::Ext::lock_delegate_dependency`]. **/ maxDelegateDependencies: u32 & AugmentedConst; /** * The maximum allowable length in bytes for storage keys. **/ maxStorageKeyLen: u32 & AugmentedConst; /** * The maximum size of the transient storage in bytes. * This includes keys, values, and previous entries used for storage rollback. **/ maxTransientStorageSize: u32 & AugmentedConst; /** * Cost schedule and limits. **/ schedule: PalletContractsSchedule & AugmentedConst; /** * Make contract callable functions marked as `#[unstable]` available. * * Contracts that use `#[unstable]` functions won't be able to be uploaded unless * this is set to `true`. This is only meant for testnets and dev nodes in order to * experiment with new features. * * # Warning * * Do **not** set to `true` on productions chains. **/ unsafeUnstableInterface: bool & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; convictionVoting: { /** * The maximum number of concurrent votes an account may have. * * Also used to compute weight, an overly large value can lead to extrinsics with large * weight estimation: see `delegate` for instance. **/ maxVotes: u32 & 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; /** * Generic const **/ [key: string]: Codec; }; coreFellowship: { /** * The maximum size in bytes submitted evidence is allowed to be. **/ evidenceSize: u32 & AugmentedConst; /** * Represents the highest possible rank in this pallet. * * Increasing this value is supported, but decreasing it may lead to a broken state. **/ maxRank: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; council: { /** * The maximum weight of a dispatch call that can be proposed and executed. **/ maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; delegatedStaking: { /** * Injected identifier for the pallet. **/ palletId: FrameSupportPalletId & AugmentedConst; /** * Fraction of the slash that is rewarded to the caller of pending slash to the agent. **/ slashRewardFraction: Perbill & 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 items which can be blacklisted. **/ maxBlacklisted: u32 & AugmentedConst; /** * The maximum number of deposits a public proposal may have at any time. **/ maxDeposits: 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 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: { /** * The minimum amount of improvement to the solution score that defines a solution as * "better" in the Signed phase. **/ betterSignedThreshold: Perbill & AugmentedConst; /** * The maximum number of winners that can be elected by this `ElectionProvider` * implementation. * * Note: This must always be greater or equal to `T::DataProvider::desired_targets()`. **/ maxWinners: u32 & AugmentedConst; minerMaxLength: u32 & AugmentedConst; minerMaxVotesPerVoter: u32 & AugmentedConst; minerMaxWeight: SpWeightsWeightV2Weight & AugmentedConst; minerMaxWinners: u32 & 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; /** * Per-byte deposit for a signed solution. **/ signedDepositByte: u128 & AugmentedConst; /** * Per-weight deposit for a signed solution. **/ signedDepositWeight: u128 & AugmentedConst; /** * The maximum amount of unchecked solutions to refund the call fee for. **/ signedMaxRefunds: u32 & 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. * * If [`Config::MinerConfig`] is being implemented to submit signed solutions (outside of * this pallet), then [`MinerConfig::solution_weight`] is used to compare against * this value. **/ signedMaxWeight: SpWeightsWeightV2Weight & AugmentedConst; /** * Base reward for a signed solution **/ signedRewardBase: u128 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; elections: { /** * 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; /** * The maximum number of candidates in a phragmen election. * * Warning: This impacts the size of the election which is run onchain. Chose wisely, and * consider how it will impact `T::WeightInfo::election_phragmen`. * * When this limit is reached no more candidates are accepted in the election. **/ maxCandidates: u32 & AugmentedConst; /** * The maximum number of voters to allow in a phragmen election. * * Warning: This impacts the size of the election which is run onchain. Chose wisely, and * consider how it will impact `T::WeightInfo::election_phragmen`. * * When the limit is reached the new voters are ignored. **/ maxVoters: u32 & AugmentedConst; /** * Maximum numbers of votes per voter. * * Warning: This impacts the size of the election which is run onchain. Chose wisely, and * consider how it will impact `T::WeightInfo::election_phragmen`. **/ maxVotesPerVoter: 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; }; fastUnstake: { /** * Deposit to take for unstaking, to make sure we're able to slash the it in order to cover * the costs of resources on unsuccessful unstake. **/ deposit: u128 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; grandpa: { /** * Max Authorities in use **/ maxAuthorities: u32 & AugmentedConst; /** * The maximum number of nominators for each validator. **/ maxNominators: u32 & AugmentedConst; /** * The maximum number of entries to keep in the set id to session index mapping. * * Since the `SetIdSession` map is only used for validating equivocations this * value should relate to the bonding duration of whatever staking system is * being used (if any). If equivocation handling is not enabled then this value * can be zero. **/ maxSetIdSessionEntries: u64 & 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 encoded byte for a registered identity. **/ byteDeposit: u128 & AugmentedConst; /** * Maximum 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 maximum length of a suffix. **/ maxSuffixLength: u32 & AugmentedConst; /** * The maximum length of a username, including its suffix and any system-added delimiters. **/ maxUsernameLength: u32 & AugmentedConst; /** * The number of blocks within which a username grant must be accepted. **/ pendingUsernameExpiration: 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; /** * The amount held on deposit per registered username. This value should change only in * runtime upgrades with proper migration of existing deposits. **/ usernameDeposit: u128 & AugmentedConst; /** * The number of blocks that must pass to enable the permanent deletion of a username by * its respective authority. **/ usernameGracePeriod: u32 & 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; }; lottery: { /** * The max number of calls available in a single lottery. **/ maxCalls: u32 & AugmentedConst; /** * Number of time we should try to generate a random number that has no modulo bias. * The larger this number, the more potential computation is used for picking the winner, * but also the more likely that the chosen winner is done fairly. **/ maxGenerateRandom: u32 & AugmentedConst; /** * The Lottery's pallet id **/ palletId: FrameSupportPalletId & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; messageQueue: { /** * The size of the page; this implies the maximum message size which can be sent. * * A good value depends on the expected message sizes, their weights, the weight that is * available for processing them and the maximal needed message size. The maximal message * size is slightly lower than this as defined by [`MaxMessageLenOf`]. **/ heapSize: u32 & AugmentedConst; /** * The maximum amount of weight (if any) to be used from remaining weight `on_idle` which * should be provided to the message queue for servicing enqueued items `on_idle`. * Useful for parachains to process messages at the same block they are received. * * If `None`, it will not call `ServiceQueues::service_queues` in `on_idle`. **/ idleMaxServiceWeight: Option & AugmentedConst; /** * The maximum number of stale pages (i.e. of overweight messages) allowed before culling * can happen. Once there are more stale pages than this, then historical pages may be * dropped, even if they contain unprocessed overweight messages. **/ maxStale: u32 & AugmentedConst; /** * The amount of weight (if any) which should be provided to the message queue for * servicing enqueued items `on_initialize`. * * This may be legitimately `None` in the case that you will call * `ServiceQueues::service_queues` manually or set [`Self::IdleMaxServiceWeight`] to have * it run in `on_idle`. **/ serviceWeight: Option & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; mixnet: { /** * The maximum number of authorities per session. **/ maxAuthorities: u32 & AugmentedConst; /** * The maximum number of external addresses for a mixnode. **/ maxExternalAddressesPerMixnode: u32 & AugmentedConst; /** * The maximum size of one of a mixnode's external addresses. **/ maxExternalAddressSize: u32 & AugmentedConst; /** * Minimum number of mixnodes. If there are fewer than this many mixnodes registered for a * session, the mixnet will not be active during the session. **/ minMixnodes: u32 & AugmentedConst; /** * Length of the first phase of each session (`CoverToCurrent`), in blocks. **/ numCoverToCurrentBlocks: u32 & AugmentedConst; /** * Length of the third phase of each session (`CoverToPrev`), in blocks. **/ numCoverToPrevBlocks: u32 & AugmentedConst; /** * The number of "slack" blocks at the end of each session. * [`maybe_register`](Pallet::maybe_register) will try to register before this slack * period, but may post registration transactions during the slack period as a last * resort. **/ numRegisterEndSlackBlocks: u32 & AugmentedConst; /** * The number of "slack" blocks at the start of each session, during which * [`maybe_register`](Pallet::maybe_register) will not attempt to post registration * transactions. **/ numRegisterStartSlackBlocks: u32 & AugmentedConst; /** * Length of the second phase of each session (`RequestsToCurrent`), in blocks. **/ numRequestsToCurrentBlocks: u32 & AugmentedConst; /** * Priority of unsigned transactions used to register mixnodes. **/ registrationPriority: u64 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; multiBlockMigrations: { /** * The maximal length of an encoded cursor. * * A good default needs to selected such that no migration will ever have a cursor with MEL * above this limit. This is statically checked in `integrity_test`. **/ cursorMaxLen: u32 & AugmentedConst; /** * The maximal length of an encoded identifier. * * A good default needs to selected such that no migration will ever have an identifier * with MEL above this limit. This is statically checked in `integrity_test`. **/ identifierMaxLen: u32 & 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: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; nftFractionalization: { /** * The deposit paid by the user locking an NFT. The deposit is returned to the original NFT * owner when the asset is unified and the NFT is unlocked. **/ deposit: u128 & AugmentedConst; /** * The newly created asset's name. **/ newAssetName: Bytes & AugmentedConst; /** * The newly created asset's symbol. **/ newAssetSymbol: Bytes & AugmentedConst; /** * The pallet's id, used for deriving its sovereign account ID. **/ palletId: FrameSupportPalletId & AugmentedConst; /** * The maximum length of a name or symbol stored on-chain. **/ stringLimit: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; nfts: { /** * The maximum approvals an item could have. **/ approvalsLimit: u32 & AugmentedConst; /** * The basic amount of funds that must be reserved when adding an attribute to an item. **/ attributeDepositBase: u128 & AugmentedConst; /** * The basic amount of funds that must be reserved for collection. **/ collectionDeposit: u128 & AugmentedConst; /** * The additional funds that must be reserved for the number of bytes store in metadata, * either "normal" metadata or attribute metadata. **/ depositPerByte: u128 & AugmentedConst; /** * Disables some of pallet's features. **/ features: u64 & AugmentedConst; /** * The maximum attributes approvals an item could have. **/ itemAttributesApprovalsLimit: u32 & AugmentedConst; /** * The basic amount of funds that must be reserved for an item. **/ itemDeposit: u128 & AugmentedConst; /** * The maximum length of an attribute key. **/ keyLimit: u32 & AugmentedConst; /** * The max number of attributes a user could set per call. **/ maxAttributesPerCall: u32 & AugmentedConst; /** * The max duration in blocks for deadlines. **/ maxDeadlineDuration: u32 & AugmentedConst; /** * The max number of tips a user could send. **/ maxTips: u32 & AugmentedConst; /** * The basic amount of funds that must be reserved when adding metadata to your item. **/ metadataDepositBase: u128 & AugmentedConst; /** * The maximum length of data stored on-chain. **/ stringLimit: u32 & AugmentedConst; /** * The maximum length of an attribute value. **/ valueLimit: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; nis: { /** * The base period for the duration queues. This is the common multiple across all * supported freezing durations that can be bid upon. **/ basePeriod: u32 & AugmentedConst; /** * 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 dequeue bids and create receipts. * * 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 consolidated into receipts in a single intake. A * larger value here means less of the block available for transactions should there be a * glut of bids. **/ maxIntakeWeight: SpWeightsWeightV2Weight & AugmentedConst; /** * Maximum number of items that may be in each duration queue. * * Must be larger than zero. **/ maxQueueLen: u32 & AugmentedConst; /** * The minimum amount of funds that may be placed in a bid. Note that this * does not actually limit the amount which may be represented in a receipt since bids may * be split up by the system. * * It should be at least big enough to ensure that there is no possible storage spam attack * or queue-filling attack. **/ minBid: u128 & AugmentedConst; /** * The minimum amount of funds which may intentionally be left remaining under a single * receipt. **/ minReceipt: Perquintill & AugmentedConst; /** * The treasury's pallet id, used for deriving its sovereign account ID. **/ palletId: FrameSupportPalletId & AugmentedConst; /** * Number of duration queues in total. This sets the maximum duration supported, which is * this value multiplied by `Period`. **/ queueCount: u32 & AugmentedConst; /** * The maximum proportion which may be thawed and the period over which it is reset. **/ thawThrottle: ITuple<[Perquintill, u32]> & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; nominationPools: { /** * The maximum pool points-to-balance ratio that an `open` pool can have. * * This is important in the event slashing takes place and the pool's points-to-balance * ratio becomes disproportional. * * Moreover, this relates to the `RewardCounter` type as well, as the arithmetic operations * are a function of number of points, and by setting this value to e.g. 10, you ensure * that the total number of points in the system are at most 10 times the total_issuance of * the chain, in the absolute worse case. * * For a value of 10, the threshold would be a pool points-to-balance ratio of 10:1. * Such a scenario would also be the equivalent of the pool being 90% slashed. **/ maxPointsToBalance: u8 & AugmentedConst; /** * The maximum number of simultaneous unbonding chunks that can exist per member. **/ maxUnbonding: u32 & AugmentedConst; /** * The nomination pool's pallet id. **/ palletId: FrameSupportPalletId & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; poolAssets: { /** * The amount of funds that must be reserved when creating a new approval. **/ approvalDeposit: u128 & AugmentedConst; /** * The amount of funds that must be reserved for a non-provider asset account to be * maintained. **/ assetAccountDeposit: u128 & AugmentedConst; /** * The basic amount of funds that must be reserved for an asset. **/ assetDeposit: u128 & AugmentedConst; /** * The basic amount of funds that must be reserved when adding metadata to your asset. **/ metadataDepositBase: u128 & AugmentedConst; /** * The additional funds that must be reserved for the number of bytes you store in your * metadata. **/ metadataDepositPerByte: u128 & AugmentedConst; /** * Max number of items to destroy per `destroy_accounts` and `destroy_approvals` call. * * Must be configured to result in a weight that makes each call fit in a block. **/ removeItemsLimit: u32 & AugmentedConst; /** * The maximum length of a name or symbol stored on-chain. **/ stringLimit: u32 & 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; }; rankedPolls: { /** * Quantization level for the referendum wakeup scheduler. A higher number will result in * fewer storage reads/writes needed for smaller voters, but also result in delays to the * automatic referendum status changes. Explicit servicing instructions are unaffected. **/ alarmInterval: u32 & AugmentedConst; /** * Maximum size of the referendum queue for a single track. **/ maxQueued: u32 & AugmentedConst; /** * The minimum amount to be used as a deposit for a public referendum proposal. **/ submissionDeposit: u128 & AugmentedConst; /** * A list of tracks. * * Note: if the tracks are dynamic, the value in the static metadata might be inaccurate. **/ tracks: Vec> & AugmentedConst; /** * The number of blocks after submission that a referendum must begin being decided by. * Once this passes, then anyone may cancel the referendum. **/ undecidingTimeout: u32 & 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. * * NOTE: The threshold programmed in this Pallet uses u16, so it does * not really make sense to have a limit here greater than u16::MAX. * But also, that is a lot more than you should probably set this value * to anyway... **/ maxFriends: u32 & 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; }; referenda: { /** * Quantization level for the referendum wakeup scheduler. A higher number will result in * fewer storage reads/writes needed for smaller voters, but also result in delays to the * automatic referendum status changes. Explicit servicing instructions are unaffected. **/ alarmInterval: u32 & AugmentedConst; /** * Maximum size of the referendum queue for a single track. **/ maxQueued: u32 & AugmentedConst; /** * The minimum amount to be used as a deposit for a public referendum proposal. **/ submissionDeposit: u128 & AugmentedConst; /** * A list of tracks. * * Note: if the tracks are dynamic, the value in the static metadata might be inaccurate. **/ tracks: Vec> & AugmentedConst; /** * The number of blocks after submission that a referendum must begin being decided by. * Once this passes, then anyone may cancel the referendum. **/ undecidingTimeout: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; revive: { /** * The [EIP-155](https://eips.ethereum.org/EIPS/eip-155) chain ID. * * This is a unique identifier assigned to each blockchain network, * preventing replay attacks. **/ chainId: u64 & AugmentedConst; /** * The percentage of the storage deposit that should be held for using a code hash. * Instantiating a contract, protects the code from being removed. In order to prevent * abuse these actions are protected with a percentage of the code deposit. **/ codeHashLockupDepositPercent: Perbill & AugmentedConst; /** * The amount of balance a caller has to pay for each byte of storage. * * # Note * * It is safe to change this value on a live chain as all refunds are pro rata. **/ depositPerByte: u128 & AugmentedConst; /** * The amount of balance a caller has to pay for each storage item. * * # Note * * It is safe to change this value on a live chain as all refunds are pro rata. **/ depositPerItem: u128 & AugmentedConst; /** * The ratio between the decimal representation of the native token and the ETH token. **/ nativeToEthRatio: u32 & AugmentedConst; /** * Make contract callable functions marked as `#[unstable]` available. * * Contracts that use `#[unstable]` functions won't be able to be uploaded unless * this is set to `true`. This is only meant for testnets and dev nodes in order to * experiment with new features. * * # Warning * * Do **not** set to `true` on productions chains. **/ unsafeUnstableInterface: bool & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; safeMode: { /** * The amount that will be reserved upon calling [`Pallet::enter`]. * * `None` disallows permissionlessly enabling the safe-mode and is a sane default. **/ enterDepositAmount: Option & AugmentedConst; /** * For how many blocks the safe-mode will be entered by [`Pallet::enter`]. **/ enterDuration: u32 & AugmentedConst; /** * The amount that will be reserved upon calling [`Pallet::extend`]. * * `None` disallows permissionlessly extending the safe-mode and is a sane default. **/ extendDepositAmount: Option & AugmentedConst; /** * For how many blocks the safe-mode can be extended by each [`Pallet::extend`] call. * * This does not impose a hard limit as the safe-mode can be extended multiple times. **/ extendDuration: u32 & AugmentedConst; /** * The minimal duration a deposit will remain reserved after safe-mode is entered or * extended, unless [`Pallet::force_release_deposit`] is successfully called sooner. * * Every deposit is tied to a specific activation or extension, thus each deposit can be * released independently after the delay for it has passed. * * `None` disallows permissionlessly releasing the safe-mode deposits and is a sane * default. **/ releaseDelay: Option & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; salary: { /** * The total budget per cycle. * * This may change over the course of a cycle without any problem. **/ budget: u128 & AugmentedConst; /** * The number of blocks within a cycle which accounts have to claim the payout. * * The number of blocks between sequential payout cycles is the sum of this and * `RegistrationPeriod`. **/ payoutPeriod: u32 & AugmentedConst; /** * The number of blocks within a cycle which accounts have to register their intent to * claim. * * The number of blocks between sequential payout cycles is the sum of this and * `PayoutPeriod`. **/ registrationPeriod: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; scheduler: { /** * The maximum weight that may be scheduled per block for any dispatchables. **/ maximumWeight: SpWeightsWeightV2Weight & AugmentedConst; /** * The maximum number of scheduled calls in the queue for a single block. * * NOTE: * + Dependent pallets' benchmarks might require a higher limit for the setting. Set a * higher limit under `runtime-benchmarks` feature. **/ maxScheduledPerBlock: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; society: { /** * The number of blocks between membership challenges. **/ challengePeriod: u32 & AugmentedConst; /** * The number of blocks on which new candidates can claim their membership and be the * named head. **/ claimPeriod: u32 & AugmentedConst; /** * The maximum number of strikes before a member gets funds slashed. **/ graceStrikes: u32 & AugmentedConst; /** * The maximum number of bids at once. **/ maxBids: u32 & AugmentedConst; /** * The maximum duration of the payout lock. **/ maxLockDuration: u32 & AugmentedConst; /** * The maximum number of payouts a member may have waiting unclaimed. **/ maxPayouts: 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 on which new candidates should be voted on. Together with * `ClaimPeriod`, this sums to the number of blocks between candidate intake periods. **/ votingPeriod: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; staking: { /** * Number of eras that staked funds must remain bonded for. **/ bondingDuration: u32 & AugmentedConst; /** * Number of eras to keep in history. * * Following information is kept for eras in `[current_era - * HistoryDepth, current_era]`: `ErasStakers`, `ErasStakersClipped`, * `ErasValidatorPrefs`, `ErasValidatorReward`, `ErasRewardPoints`, * `ErasTotalStake`, `ErasStartSessionIndex`, `ClaimedRewards`, `ErasStakersPaged`, * `ErasStakersOverview`. * * Must be more than the number of eras delayed by session. * I.e. active era must always be in history. I.e. `active_era > * current_era - history_depth` must be guaranteed. * * If migrating an existing pallet from storage value to config value, * this should be set to same value or greater as in storage. * * Note: `HistoryDepth` is used as the upper bound for the `BoundedVec` * item `StakingLedger.legacy_claimed_rewards`. Setting this value lower than * the existing value can lead to inconsistencies in the * `StakingLedger` and will need to be handled properly in a migration. * The test `reducing_history_depth_abrupt` shows this effect. **/ historyDepth: u32 & AugmentedConst; /** * The maximum size of each `T::ExposurePage`. * * An `ExposurePage` is weakly bounded to a maximum of `MaxExposurePageSize` * nominators. * * For older non-paged exposure, a reward payout was restricted to the top * `MaxExposurePageSize` nominators. This is to limit the i/o cost for the * nominator payout. * * Note: `MaxExposurePageSize` is used to bound `ClaimedRewards` and is unsafe to reduce * without handling it in a migration. **/ maxExposurePageSize: u32 & AugmentedConst; /** * The maximum number of `unlocking` chunks a [`StakingLedger`] can * have. Effectively determines how many unique eras a staker may be * unbonding in. * * Note: `MaxUnlockingChunks` is used as the upper bound for the * `BoundedVec` item `StakingLedger.unlocking`. Setting this value * lower than the existing value can lead to inconsistencies in the * `StakingLedger` and will need to be handled properly in a runtime * migration. The test `reducing_max_unlocking_chunks_abrupt` shows * this effect. **/ maxUnlockingChunks: 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; }; statement: { /** * Cost of data byte used for priority calculation. **/ byteCost: u128 & AugmentedConst; /** * Maximum data bytes allowed per account. **/ maxAllowedBytes: u32 & AugmentedConst; /** * Maximum number of statements allowed per account. **/ maxAllowedStatements: u32 & AugmentedConst; /** * Minimum data bytes allowed per account. **/ minAllowedBytes: u32 & AugmentedConst; /** * Minimum number of statements allowed per account. **/ minAllowedStatements: u32 & AugmentedConst; /** * Min balance for priority statements. **/ statementCost: u128 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; stateTrieMigration: { /** * Maximal number of bytes that a key can have. * * FRAME itself does not limit the key length. * The concrete value must therefore depend on your storage usage. * A [`frame_support::storage::StorageNMap`] for example can have an arbitrary number of * keys which are then hashed and concatenated, resulting in arbitrarily long keys. * * Use the *state migration RPC* to retrieve the length of the longest key in your * storage: * * The migration will halt with a `Halted` event if this value is too small. * Since there is no real penalty from over-estimating, it is advised to use a large * value. The default is 512 byte. * * Some key lengths for reference: * - [`frame_support::storage::StorageValue`]: 32 byte * - [`frame_support::storage::StorageMap`]: 64 byte * - [`frame_support::storage::StorageDoubleMap`]: 96 byte * * For more info see * **/ maxKeyLen: 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: SpWeightsRuntimeDbWeight & AugmentedConst; /** * The designated SS58 prefix of this chain. * * This replaces the "ss58Format" property declared in the chain spec. Reason is * that the runtime should know about the prefix in order to make use of it as * an identifier of the chain. **/ ss58Prefix: u16 & AugmentedConst; /** * Get the chain's in-code version. **/ version: SpVersionRuntimeVersion & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; technicalCommittee: { /** * The maximum weight of a dispatch call that can be proposed and executed. **/ maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; timestamp: { /** * The minimum period between blocks. * * Be aware that this is different to the *expected* period that the block production * apparatus provides. Your chosen consensus system will generally work with this to * determine a sensible block time. For example, in the Aura pallet it will be double this * period on default settings. **/ minimumPeriod: 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 maximum amount for a single tip. **/ maxTipAmount: u128 & 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 non-zero amount held on deposit for placing a tip report. **/ tipReportDepositBase: u128 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; transactionPayment: { /** * A fee multiplier for `Operational` extrinsics to compute "virtual tip" to boost their * `priority` * * This value is multiplied by the `final_fee` to obtain a "virtual tip" that is later * added to a tip component in regular `priority` calculations. * It means that a `Normal` transaction can front-run a similarly-sized `Operational` * extrinsic (with no tip), by including a tip value greater than the virtual tip. * * ```rust,ignore * // For `Normal` * let priority = priority_calc(tip); * * // For `Operational` * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier; * let priority = priority_calc(tip + virtual_tip); * ``` * * Note that since we use `final_fee` the multiplier applies also to the regular `tip` * sent with the transaction. So, not only does the transaction get a priority bump based * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational` * transactions. **/ operationalFeeMultiplier: u8 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; treasury: { /** * Percentage of spare funds (if any) that are burnt per spend period. **/ burn: Permill & AugmentedConst; /** * DEPRECATED: associated with `spend_local` call and will be removed in May 2025. * Refer to for migration to `spend`. * * The maximum number of approvals that can wait in the spending queue. * * NOTE: This parameter is also used within the Bounties Pallet extension if enabled. **/ maxApprovals: u32 & AugmentedConst; /** * The treasury's pallet id, used for deriving its sovereign account ID. **/ palletId: FrameSupportPalletId & AugmentedConst; /** * The period during which an approved treasury spend has to be claimed. **/ payoutPeriod: u32 & AugmentedConst; /** * Gets this pallet's derived pot account. **/ potAccount: AccountId32 & AugmentedConst; /** * Period between successive spends. **/ spendPeriod: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; txPause: { /** * Maximum length for pallet name and call name SCALE encoded string names. * * TOO LONG NAMES WILL BE TREATED AS PAUSED. **/ maxNameLen: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; uniques: { /** * The basic amount of funds that must be reserved when adding an attribute to an item. **/ attributeDepositBase: u128 & AugmentedConst; /** * The basic amount of funds that must be reserved for collection. **/ collectionDeposit: u128 & AugmentedConst; /** * The additional funds that must be reserved for the number of bytes store in metadata, * either "normal" metadata or attribute metadata. **/ depositPerByte: u128 & AugmentedConst; /** * The basic amount of funds that must be reserved for an item. **/ itemDeposit: u128 & AugmentedConst; /** * The maximum length of an attribute key. **/ keyLimit: u32 & AugmentedConst; /** * The basic amount of funds that must be reserved when adding metadata to your item. **/ metadataDepositBase: u128 & AugmentedConst; /** * The maximum length of data stored on-chain. **/ stringLimit: u32 & AugmentedConst; /** * The maximum length of an attribute value. **/ valueLimit: 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; }; voterList: { /** * The list of thresholds separating the various bags. * * Ids are separated into unsorted bags according to their score. This specifies the * thresholds separating the bags. An id's bag is the largest bag for which the id's score * 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 score tend to come before ids of lower * score, 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 `Score::MAX`; that value does not need to be * specified within the bag. For any two threshold lists, if one ends with * `Score::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 score 0 or 1 will fall * into bag 0, an id with score 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; }; } }