1772 lines
65 KiB
TypeScript
1772 lines
65 KiB
TypeScript
// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
|
|
/* eslint-disable */
|
|
|
|
// import type lookup before we augment - in some environments
|
|
// this is required to allow for ambient/previous definitions
|
|
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 { Perbill, Percent, Permill, Perquintill } from '@polkadot/types/interfaces/runtime';
|
|
import type { FrameSupportPalletId, FrameSupportTokensFungibleUnionOfNativeOrWithId, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, PalletContractsEnvironment, PalletContractsSchedule, PalletReferendaTrackInfo, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, SpWeightsWeightV2Weight } from '@polkadot/types/lookup';
|
|
|
|
export type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;
|
|
|
|
declare module '@polkadot/api-base/types/consts' {
|
|
interface AugmentedConsts<ApiType extends ApiTypes> {
|
|
alliance: {
|
|
/**
|
|
* The deposit required for submitting candidacy.
|
|
**/
|
|
allyDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of announcements.
|
|
**/
|
|
maxAnnouncementsCount: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of members per member role.
|
|
**/
|
|
maxMembersCount: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of the unscrupulous items supported by the pallet.
|
|
**/
|
|
maxUnscrupulousItems: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum length of a website URL.
|
|
**/
|
|
maxWebsiteUrlLength: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
allianceMotion: {
|
|
/**
|
|
* The maximum weight of a dispatch call that can be proposed and executed.
|
|
**/
|
|
maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
assetConversion: {
|
|
/**
|
|
* A fee to withdraw the liquidity.
|
|
**/
|
|
liquidityWithdrawalFee: Permill & AugmentedConst<ApiType>;
|
|
/**
|
|
* A % the liquidity providers will take of every swap. Represents 10ths of a percent.
|
|
**/
|
|
lpFee: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The max number of hops in a swap.
|
|
**/
|
|
maxSwapPathLength: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The minimum LP token amount that could be minted. Ameliorates rounding errors.
|
|
**/
|
|
mintMinLiquidity: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The pallet's id, used for deriving its sovereign account ID.
|
|
**/
|
|
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
|
|
/**
|
|
* A one-time fee to setup the pool.
|
|
**/
|
|
poolSetupFee: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Asset class from [`Config::Assets`] used to pay the [`Config::PoolSetupFee`].
|
|
**/
|
|
poolSetupFeeAsset: FrameSupportTokensFungibleUnionOfNativeOrWithId & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
assets: {
|
|
/**
|
|
* The amount of funds that must be reserved when creating a new approval.
|
|
**/
|
|
approvalDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The amount of funds that must be reserved for a non-provider asset account to be
|
|
* maintained.
|
|
**/
|
|
assetAccountDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved for an asset.
|
|
**/
|
|
assetDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved when adding metadata to your asset.
|
|
**/
|
|
metadataDepositBase: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The additional funds that must be reserved for the number of bytes you store in your
|
|
* metadata.
|
|
**/
|
|
metadataDepositPerByte: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* The maximum length of a name or symbol stored on-chain.
|
|
**/
|
|
stringLimit: 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>;
|
|
/**
|
|
* The maximum number of nominators for each validator.
|
|
**/
|
|
maxNominators: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* The maximum number of individual freeze locks that can exist on an account at any time.
|
|
**/
|
|
maxFreezes: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
beefy: {
|
|
/**
|
|
* The maximum number of authorities that can be added.
|
|
**/
|
|
maxAuthorities: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of nominators for each validator.
|
|
**/
|
|
maxNominators: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
bounties: {
|
|
/**
|
|
* 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>;
|
|
/**
|
|
* Maximum amount of funds that should be placed in a deposit for making a proposal.
|
|
**/
|
|
curatorDepositMax: Option<u128> & AugmentedConst<ApiType>;
|
|
/**
|
|
* Minimum amount of funds that should be placed in a deposit for making a proposal.
|
|
**/
|
|
curatorDepositMin: Option<u128> & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<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;
|
|
};
|
|
broker: {
|
|
/**
|
|
* Maximum number of legacy leases.
|
|
**/
|
|
maxLeasedCores: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Maximum number of system cores.
|
|
**/
|
|
maxReservedCores: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Identifier from which the internal Pot is generated.
|
|
**/
|
|
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
|
|
/**
|
|
* Number of Relay-chain blocks per timeslice.
|
|
**/
|
|
timeslicePeriod: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
childBounties: {
|
|
/**
|
|
* Minimum value for a child-bounty.
|
|
**/
|
|
childBountyValueMinimum: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Maximum number of child bounties that can be added to a parent bounty.
|
|
**/
|
|
maxActiveChildBountyCount: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Fallback value to limit the storage deposit if it's not being set by the caller.
|
|
**/
|
|
defaultDepositLimit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* The maximum length of the debug buffer in bytes.
|
|
**/
|
|
maxDebugBufferLen: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of delegate_dependencies that a contract can lock with
|
|
* [`chain_extension::Ext::lock_delegate_dependency`].
|
|
**/
|
|
maxDelegateDependencies: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum allowable length in bytes for storage keys.
|
|
**/
|
|
maxStorageKeyLen: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum size of the transient storage in bytes.
|
|
* This includes keys, values, and previous entries used for storage rollback.
|
|
**/
|
|
maxTransientStorageSize: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Cost schedule and limits.
|
|
**/
|
|
schedule: PalletContractsSchedule & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<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>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
coreFellowship: {
|
|
/**
|
|
* The maximum size in bytes submitted evidence is allowed to be.
|
|
**/
|
|
evidenceSize: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
council: {
|
|
/**
|
|
* The maximum weight of a dispatch call that can be proposed and executed.
|
|
**/
|
|
maxProposalWeight: SpWeightsWeightV2Weight & 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 items which can be blacklisted.
|
|
**/
|
|
maxBlacklisted: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of deposits a public proposal may have at any time.
|
|
**/
|
|
maxDeposits: 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 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: {
|
|
/**
|
|
* The minimum amount of improvement to the solution score that defines a solution as
|
|
* "better" in the Signed phase.
|
|
**/
|
|
betterSignedThreshold: Perbill & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
minerMaxLength: u32 & AugmentedConst<ApiType>;
|
|
minerMaxVotesPerVoter: u32 & AugmentedConst<ApiType>;
|
|
minerMaxWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
|
|
minerMaxWinners: u32 & 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>;
|
|
/**
|
|
* Per-byte deposit for a signed solution.
|
|
**/
|
|
signedDepositByte: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Per-weight deposit for a signed solution.
|
|
**/
|
|
signedDepositWeight: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum amount of unchecked solutions to refund the call fee for.
|
|
**/
|
|
signedMaxRefunds: u32 & 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.
|
|
*
|
|
* 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<ApiType>;
|
|
/**
|
|
* Base reward for a signed solution
|
|
**/
|
|
signedRewardBase: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
elections: {
|
|
/**
|
|
* 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>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<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;
|
|
};
|
|
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<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
grandpa: {
|
|
/**
|
|
* Max Authorities in use
|
|
**/
|
|
maxAuthorities: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of nominators for each validator.
|
|
**/
|
|
maxNominators: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<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 encoded byte for a registered identity.
|
|
**/
|
|
byteDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Maximum 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 maximum length of a suffix.
|
|
**/
|
|
maxSuffixLength: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum length of a username, including its suffix and any system-added delimiters.
|
|
**/
|
|
maxUsernameLength: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The number of blocks within which a username grant must be accepted.
|
|
**/
|
|
pendingUsernameExpiration: 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;
|
|
};
|
|
lottery: {
|
|
/**
|
|
* The max number of calls available in a single lottery.
|
|
**/
|
|
maxCalls: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* The Lottery's pallet id
|
|
**/
|
|
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<SpWeightsWeightV2Weight> & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<SpWeightsWeightV2Weight> & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
mixnet: {
|
|
/**
|
|
* The maximum number of authorities per session.
|
|
**/
|
|
maxAuthorities: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of external addresses for a mixnode.
|
|
**/
|
|
maxExternalAddressesPerMixnode: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum size of one of a mixnode's external addresses.
|
|
**/
|
|
maxExternalAddressSize: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Length of the first phase of each session (`CoverToCurrent`), in blocks.
|
|
**/
|
|
numCoverToCurrentBlocks: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Length of the third phase of each session (`CoverToPrev`), in blocks.
|
|
**/
|
|
numCoverToPrevBlocks: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Length of the second phase of each session (`RequestsToCurrent`), in blocks.
|
|
**/
|
|
numRequestsToCurrentBlocks: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Priority of unsigned transactions used to register mixnodes.
|
|
**/
|
|
registrationPriority: u64 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<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: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* The newly created asset's name.
|
|
**/
|
|
newAssetName: Bytes & AugmentedConst<ApiType>;
|
|
/**
|
|
* The newly created asset's symbol.
|
|
**/
|
|
newAssetSymbol: Bytes & AugmentedConst<ApiType>;
|
|
/**
|
|
* The pallet's id, used for deriving its sovereign account ID.
|
|
**/
|
|
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum length of a name or symbol stored on-chain.
|
|
**/
|
|
stringLimit: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
nfts: {
|
|
/**
|
|
* The maximum approvals an item could have.
|
|
**/
|
|
approvalsLimit: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved when adding an attribute to an item.
|
|
**/
|
|
attributeDepositBase: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved for collection.
|
|
**/
|
|
collectionDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The additional funds that must be reserved for the number of bytes store in metadata,
|
|
* either "normal" metadata or attribute metadata.
|
|
**/
|
|
depositPerByte: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Disables some of pallet's features.
|
|
**/
|
|
features: u64 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum attributes approvals an item could have.
|
|
**/
|
|
itemAttributesApprovalsLimit: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved for an item.
|
|
**/
|
|
itemDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum length of an attribute key.
|
|
**/
|
|
keyLimit: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The max number of attributes a user could set per call.
|
|
**/
|
|
maxAttributesPerCall: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The max duration in blocks for deadlines.
|
|
**/
|
|
maxDeadlineDuration: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The max number of tips a user could send.
|
|
**/
|
|
maxTips: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved when adding metadata to your item.
|
|
**/
|
|
metadataDepositBase: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum length of data stored on-chain.
|
|
**/
|
|
stringLimit: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum length of an attribute value.
|
|
**/
|
|
valueLimit: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Maximum number of items that may be in each duration queue.
|
|
*
|
|
* Must be larger than zero.
|
|
**/
|
|
maxQueueLen: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* The minimum amount of funds which may intentionally be left remaining under a single
|
|
* receipt.
|
|
**/
|
|
minReceipt: Perquintill & AugmentedConst<ApiType>;
|
|
/**
|
|
* The treasury's pallet id, used for deriving its sovereign account ID.
|
|
**/
|
|
palletId: FrameSupportPalletId & 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>;
|
|
/**
|
|
* The maximum proportion which may be thawed and the period over which it is reset.
|
|
**/
|
|
thawThrottle: ITuple<[Perquintill, u32]> & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* The maximum number of simultaneous unbonding chunks that can exist per member.
|
|
**/
|
|
maxUnbonding: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The nomination pool's pallet id.
|
|
**/
|
|
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
poolAssets: {
|
|
/**
|
|
* The amount of funds that must be reserved when creating a new approval.
|
|
**/
|
|
approvalDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The amount of funds that must be reserved for a non-provider asset account to be
|
|
* maintained.
|
|
**/
|
|
assetAccountDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved for an asset.
|
|
**/
|
|
assetDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved when adding metadata to your asset.
|
|
**/
|
|
metadataDepositBase: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The additional funds that must be reserved for the number of bytes you store in your
|
|
* metadata.
|
|
**/
|
|
metadataDepositPerByte: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* The maximum length of a name or symbol stored on-chain.
|
|
**/
|
|
stringLimit: u32 & 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;
|
|
};
|
|
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<ApiType>;
|
|
/**
|
|
* Maximum size of the referendum queue for a single track.
|
|
**/
|
|
maxQueued: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The minimum amount to be used as a deposit for a public referendum proposal.
|
|
**/
|
|
submissionDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Information concerning the different referendum tracks.
|
|
**/
|
|
tracks: Vec<ITuple<[u16, PalletReferendaTrackInfo]>> & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<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.
|
|
*
|
|
* 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<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;
|
|
};
|
|
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<ApiType>;
|
|
/**
|
|
* Maximum size of the referendum queue for a single track.
|
|
**/
|
|
maxQueued: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The minimum amount to be used as a deposit for a public referendum proposal.
|
|
**/
|
|
submissionDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Information concerning the different referendum tracks.
|
|
**/
|
|
tracks: Vec<ITuple<[u16, PalletReferendaTrackInfo]>> & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<u128> & AugmentedConst<ApiType>;
|
|
/**
|
|
* For how many blocks the safe-mode will be entered by [`Pallet::enter`].
|
|
**/
|
|
enterDuration: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The amount that will be reserved upon calling [`Pallet::extend`].
|
|
*
|
|
* `None` disallows permissionlessly extending the safe-mode and is a sane default.
|
|
**/
|
|
extendDepositAmount: Option<u128> & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<u32> & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
scheduler: {
|
|
/**
|
|
* The maximum weight that may be scheduled per block for any dispatchables.
|
|
**/
|
|
maximumWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
society: {
|
|
/**
|
|
* The number of blocks between membership challenges.
|
|
**/
|
|
challengePeriod: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The number of blocks on which new candidates can claim their membership and be the
|
|
* named head.
|
|
**/
|
|
claimPeriod: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of strikes before a member gets funds slashed.
|
|
**/
|
|
graceStrikes: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of bids at once.
|
|
**/
|
|
maxBids: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum duration of the payout lock.
|
|
**/
|
|
maxLockDuration: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum number of payouts a member may have waiting unclaimed.
|
|
**/
|
|
maxPayouts: 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 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<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
staking: {
|
|
/**
|
|
* Number of eras that staked funds must remain bonded for.
|
|
**/
|
|
bondingDuration: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<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;
|
|
};
|
|
statement: {
|
|
/**
|
|
* Cost of data byte used for priority calculation.
|
|
**/
|
|
byteCost: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Maximum data bytes allowed per account.
|
|
**/
|
|
maxAllowedBytes: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Maximum number of statements allowed per account.
|
|
**/
|
|
maxAllowedStatements: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Minimum data bytes allowed per account.
|
|
**/
|
|
minAllowedBytes: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Minimum number of statements allowed per account.
|
|
**/
|
|
minAllowedStatements: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Min balance for priority statements.
|
|
**/
|
|
statementCost: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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: <https://github.com/paritytech/substrate/issues/11642>
|
|
*
|
|
* 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
|
|
* <https://www.shawntabrizi.com/blog/substrate/querying-substrate-storage-via-rpc/>
|
|
**/
|
|
maxKeyLen: 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: SpWeightsRuntimeDbWeight & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* Get the chain's in-code version.
|
|
**/
|
|
version: SpVersionRuntimeVersion & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
technicalCommittee: {
|
|
/**
|
|
* The maximum weight of a dispatch call that can be proposed and executed.
|
|
**/
|
|
maxProposalWeight: SpWeightsWeightV2Weight & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<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 maximum amount for a single tip.
|
|
**/
|
|
maxTipAmount: u128 & 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 non-zero amount held on deposit for placing a tip report.
|
|
**/
|
|
tipReportDepositBase: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<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.
|
|
*
|
|
* NOTE: This parameter is also used within the Bounties Pallet extension if enabled.
|
|
**/
|
|
maxApprovals: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The treasury's pallet id, used for deriving its sovereign account ID.
|
|
**/
|
|
palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
|
|
/**
|
|
* The period during which an approved treasury spend has to be claimed.
|
|
**/
|
|
payoutPeriod: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* Period between successive spends.
|
|
**/
|
|
spendPeriod: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* 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<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved for collection.
|
|
**/
|
|
collectionDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The additional funds that must be reserved for the number of bytes store in metadata,
|
|
* either "normal" metadata or attribute metadata.
|
|
**/
|
|
depositPerByte: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved for an item.
|
|
**/
|
|
itemDeposit: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum length of an attribute key.
|
|
**/
|
|
keyLimit: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The basic amount of funds that must be reserved when adding metadata to your item.
|
|
**/
|
|
metadataDepositBase: u128 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum length of data stored on-chain.
|
|
**/
|
|
stringLimit: u32 & AugmentedConst<ApiType>;
|
|
/**
|
|
* The maximum length of an attribute value.
|
|
**/
|
|
valueLimit: 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;
|
|
};
|
|
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<u64> & AugmentedConst<ApiType>;
|
|
/**
|
|
* Generic const
|
|
**/
|
|
[key: string]: Codec;
|
|
};
|
|
} // AugmentedConsts
|
|
} // declare module
|