import '@polkadot/api-base/types/consts'; import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types'; import type { Option, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec'; import type { Codec } from '@polkadot/types-codec/types'; import type { AccountId32, Perbill, Permill } from '@polkadot/types/interfaces/runtime'; import type { FrameSupportPalletId, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, SpWeightsWeightV2Weight } from '@polkadot/types/lookup'; export type __AugmentedConst = AugmentedConst; declare module '@polkadot/api-base/types/consts' { interface AugmentedConsts { aura: { /** * The slot duration Aura should run with, expressed in milliseconds. * The effective value of this type should not change while the chain is running. * * For backwards compatibility either use [`MinimumPeriodTimesTwo`] or a const. **/ slotDuration: u64 & 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; }; capacity: { /** * How much FRQCY one unit of Capacity costs **/ capacityPerToken: Perbill & AugmentedConst; /** * The number of blocks in a RewardEra **/ eraLength: u32 & AugmentedConst; /** * Maximum number of blocks an epoch can be **/ maxEpochLength: u32 & AugmentedConst; /** * A staker may not retarget more than MaxRetargetsPerRewardEra **/ maxRetargetsPerRewardEra: u32 & AugmentedConst; /** * The maximum number of unlocking chunks a StakingAccountLedger can have. * It determines how many concurrent unstaked chunks may exist. **/ maxUnlockingChunks: u32 & AugmentedConst; /** * The minimum required token amount to stake. It facilitates cleaning dust when unstaking. **/ minimumStakingAmount: u128 & AugmentedConst; /** * The minimum required token amount to remain in the account after staking. **/ minimumTokenBalance: u128 & AugmentedConst; /** * The maximum number of eras over which one can claim rewards * Note that you can claim rewards even if you no longer are boosting, because you * may claim rewards for past eras up to the history limit. * MUST be a multiple of [`Self::RewardPoolChunkLength`] **/ providerBoostHistoryLimit: u32 & AugmentedConst; /** * the percentage cap per era of an individual Provider Boost reward **/ rewardPercentCap: Permill & AugmentedConst; /** * The number of chunks of Reward Pool history we expect to store * Is a divisor of [`Self::ProviderBoostHistoryLimit`] **/ rewardPoolChunkLength: u32 & AugmentedConst; /** * The fixed size of the reward pool in each Reward Era. **/ rewardPoolPerEra: u128 & AugmentedConst; /** * The number of Epochs before you can unlock tokens after unstaking. **/ unstakingThawPeriod: u16 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; collatorSelection: { kickThreshold: u32 & AugmentedConst; /** * Maximum number of candidates that we should have. * * This does not take into account the invulnerables. **/ maxCandidates: u32 & AugmentedConst; /** * Maximum number of invulnerables. **/ maxInvulnerables: u32 & AugmentedConst; /** * Minimum number eligible collators. Should always be greater than zero. This includes * Invulnerable collators. This ensures that there will always be one collator who can * produce a block. **/ minEligibleCollators: u32 & AugmentedConst; /** * Gets this pallet's derived pot account. **/ potAccount: AccountId32 & AugmentedConst; /** * Account Identifier from which the internal Pot is generated. **/ potId: FrameSupportPalletId & 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; }; 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; }; frequencyTxPayment: { /** * The maxmimum number of capacity calls that can be batched together. **/ maximumCapacityBatchLength: u8 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; handles: { /** * The maximum suffix value **/ handleSuffixMax: u16 & AugmentedConst; /** * The minimum suffix value **/ handleSuffixMin: u16 & AugmentedConst; /** * The number of blocks before a signature can be ejected from the PayloadSignatureRegistryList **/ mortalityWindowSize: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; messages: { /** * The maximum size of a message payload bytes. **/ messagesMaxPayloadSizeBytes: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; msa: { /** * Maximum count of items granted for publishing data per Provider **/ maxGrantsPerDelegation: u32 & AugmentedConst; /** * Maximum language code size for a locale **/ maxLanguageCodeSize: u32 & AugmentedConst; /** * Total number of locales supported **/ maxLocaleCount: u32 & AugmentedConst; /** * Maximum cid size for a locale **/ maxLogoCidSize: u32 & AugmentedConst; /** * Maximum logo size for a locale **/ maxLogoSize: u32 & AugmentedConst; /** * Maximum provider name size allowed per MSA association **/ maxProviderNameSize: u32 & AugmentedConst; /** * Maximum count of keys allowed per MSA **/ maxPublicKeysPerMsa: u8 & AugmentedConst; /** * The maximum number of signatures that can be stored in PayloadSignatureRegistryList. **/ maxSignaturesStored: Option & AugmentedConst; /** * The number of blocks before a signature can be ejected from the PayloadSignatureRegistryList **/ mortalityWindowSize: u32 & 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; }; parachainSystem: { /** * Returns the parachain ID we are running with. **/ selfParaId: 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; }; 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; }; schemas: { /** * Maximum number of Intents that can belong to an IntentGroup **/ maxIntentsPerIntentGroup: u32 & AugmentedConst; /** * Maximum number of schema settings that can be registered per schema (if any) **/ maxSchemaSettingsPerSchema: u32 & AugmentedConst; /** * Minimum length of Schema model size in bytes **/ minSchemaModelSizeBytes: u32 & AugmentedConst; /** * Maximum length of a Schema model Bounded Vec **/ schemaModelMaxBytesBoundedVecLimit: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; statefulStorage: { /** * The maximum number of actions in itemized actions **/ maxItemizedActionsCount: u32 & AugmentedConst; /** * The maximum size of a single item in an itemized storage model (in bytes) **/ maxItemizedBlobSizeBytes: u32 & AugmentedConst; /** * The maximum size of a page (in bytes) for an Itemized storage model **/ maxItemizedPageSizeBytes: u32 & AugmentedConst; /** * The maximum number of pages in a Paginated storage model **/ maxPaginatedPageId: u16 & AugmentedConst; /** * The maximum size of a page (in bytes) for a Paginated storage model **/ maxPaginatedPageSizeBytes: u32 & AugmentedConst; /** * The number of blocks that we allow for a signed payload to be valid. This is mainly used * to make sure a signed payload would not be replayable. **/ mortalityWindowSize: 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; }; timeRelease: { /** * The minimum amount transferred to call `transfer`. **/ minReleaseTransfer: u128 & 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; }; 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; /** * 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; /** * Fraction of a proposal's value that should be bonded in order to place the proposal. * An accepted proposal gets these back. A rejected proposal does not. **/ proposalBond: Permill & AugmentedConst; /** * Maximum amount of funds that should be placed in a deposit for making a proposal. **/ proposalBondMaximum: Option & AugmentedConst; /** * Minimum amount of funds that should be placed in a deposit for making a proposal. **/ proposalBondMinimum: u128 & AugmentedConst; /** * Period between successive spends. **/ spendPeriod: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; utility: { /** * The limit on the number of batched calls. **/ batchedCallsLimit: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; } }