import type { Vec, u16, u32, u8 } from '@polkadot/types'; import type { Codec } from '@polkadot/types/types'; import type { CurrencyIdOf } from './webb'; import type { Schedule } from '@polkadot/types/interfaces/contracts'; import type { AccountId, Balance, BalanceOf, BlockNumber, LockIdentifier, Moment, PalletId, Perbill, Percent, Permill, RuntimeDbWeight, Weight } from '@polkadot/types/interfaces/runtime'; import type { SessionIndex } from '@polkadot/types/interfaces/session'; import type { EraIndex } from '@polkadot/types/interfaces/staking'; import type { RuntimeVersion } from '@polkadot/types/interfaces/state'; import type { WeightToFeeCoefficient } from '@polkadot/types/interfaces/support'; import type { BlockLength, BlockWeights } from '@polkadot/types/interfaces/system'; import type { ApiTypes } from '@polkadot/api/types'; declare module '@polkadot/api/types/consts' { interface AugmentedConsts { balances: { /** * The minimum amount required to keep an account open. **/ existentialDeposit: Balance & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; bounties: { /** * Percentage of the curator fee that will be reserved upfront as deposit for bounty curator. **/ bountyCuratorDeposit: Permill & AugmentedConst; /** * The amount held on deposit for placing a bounty proposal. **/ bountyDepositBase: BalanceOf & AugmentedConst; /** * The delay period for which a bounty beneficiary need to wait before claim the payout. **/ bountyDepositPayoutDelay: BlockNumber & AugmentedConst; /** * Bounty duration in blocks. **/ bountyUpdatePeriod: BlockNumber & AugmentedConst; /** * Minimum value for a bounty. **/ bountyValueMinimum: BalanceOf & AugmentedConst; /** * The amount held on deposit per byte within bounty description. **/ dataDepositPerByte: BalanceOf & AugmentedConst; /** * Maximum acceptable reason length. **/ maximumReasonLength: u32 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; contracts: { /** * The maximum number of tries that can be queued for deletion. **/ deletionQueueDepth: u32 & AugmentedConst; /** * The maximum amount of weight that can be consumed per block for lazy trie removal. **/ deletionWeightLimit: Weight & AugmentedConst; /** * The balance every contract needs to deposit to stay alive indefinitely. * * This is different from the [`Self::TombstoneDeposit`] because this only needs to be * deposited while the contract is alive. Costs for additional storage are added to * this base cost. * * This is a simple way to ensure that contracts with empty storage eventually get deleted by * making them pay rent. This creates an incentive to remove them early in order to save rent. **/ depositPerContract: BalanceOf & AugmentedConst; /** * The balance a contract needs to deposit per storage byte to stay alive indefinitely. * * Let's suppose the deposit is 1,000 BU (balance units)/byte and the rent is 1 BU/byte/day, * then a contract with 1,000,000 BU that uses 1,000 bytes of storage would pay no rent. * But if the balance reduced to 500,000 BU and the storage stayed the same at 1,000, * then it would pay 500 BU/day. **/ depositPerStorageByte: BalanceOf & AugmentedConst; /** * The balance a contract needs to deposit per storage item to stay alive indefinitely. * * It works the same as [`Self::DepositPerStorageByte`] but for storage items. **/ depositPerStorageItem: BalanceOf & AugmentedConst; /** * The fraction of the deposit that should be used as rent per block. * * When a contract hasn't enough balance deposited to stay alive indefinitely it needs * to pay per block for the storage it consumes that is not covered by the deposit. * This determines how high this rent payment is per block as a fraction of the deposit. **/ rentFraction: Perbill & AugmentedConst; /** * Cost schedule and limits. **/ schedule: Schedule & AugmentedConst; /** * Number of block delay an extrinsic claim surcharge has. * * When claim surcharge is called by an extrinsic the rent is checked * for current_block - delay **/ signedClaimHandicap: BlockNumber & AugmentedConst; /** * Reward that is received by the party whose touch has led * to removal of a contract. **/ surchargeReward: BalanceOf & AugmentedConst; /** * The minimum amount required to generate a tombstone. **/ tombstoneDeposit: BalanceOf & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; currencies: { getNativeCurrencyId: CurrencyIdOf & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; democracy: { /** * Period in blocks where an external proposal may not be re-submitted after being vetoed. **/ cooloffPeriod: BlockNumber & AugmentedConst; /** * The minimum period of locking and 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: BlockNumber & AugmentedConst; /** * Minimum voting period allowed for an emergency referendum. **/ fastTrackVotingPeriod: BlockNumber & AugmentedConst; /** * How often (in blocks) new public referenda are launched. **/ launchPeriod: BlockNumber & AugmentedConst; /** * The maximum number of votes for an account. **/ maxVotes: u32 & AugmentedConst; /** * The minimum amount to be used as a deposit for a public referendum proposal. **/ minimumDeposit: BalanceOf & AugmentedConst; /** * The amount of balance that must be deposited per byte of preimage stored. **/ preimageByteDeposit: BalanceOf & AugmentedConst; /** * How often (in blocks) to check for new votes. **/ votingPeriod: BlockNumber & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; electionProviderMultiPhase: { /** * 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: BlockNumber & AugmentedConst; /** * Duration of the signed phase. **/ signedPhase: BlockNumber & AugmentedConst; /** * The minimum amount of improvement to the solution score that defines a solution as * "better" (in any phase). **/ solutionImprovementThreshold: Perbill & AugmentedConst; /** * Duration of the unsigned phase. **/ unsignedPhase: BlockNumber & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; identity: { /** * The amount held on deposit for a registered identity **/ basicDeposit: BalanceOf & AugmentedConst; /** * The amount held on deposit per additional field for a registered identity. **/ fieldDeposit: BalanceOf & AugmentedConst; /** * Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O * required to access an identity, but can be pretty high. **/ maxAdditionalFields: u32 & AugmentedConst; /** * Maxmimum number of registrars allowed in the system. Needed to bound the complexity * of, e.g., updating judgements. **/ maxRegistrars: u32 & AugmentedConst; /** * The maximum number of sub-accounts allowed per identified account. **/ maxSubAccounts: u32 & AugmentedConst; /** * The amount held on deposit for a registered subaccount. This should account for the fact * that one storage item's value will increase by the size of an account ID, and there will be * another trie item whose value is the size of an account ID plus 32 bytes. **/ subAccountDeposit: BalanceOf & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; indices: { /** * The deposit needed for reserving an index. **/ deposit: BalanceOf & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; mixer: { /** * Default admin key **/ defaultAdmin: AccountId & AugmentedConst; /** * The small deposit length **/ depositLength: BlockNumber & AugmentedConst; /** * Native currency id **/ nativeCurrencyId: CurrencyIdOf & AugmentedConst; palletId: PalletId & 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. **/ depositBase: BalanceOf & AugmentedConst; /** * The amount of currency needed per unit threshold when creating a multisig execution. **/ depositFactor: BalanceOf & AugmentedConst; /** * The maximum amount of signatories allowed for a given multisig. **/ maxSignatories: u16 & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; nft: { /** * The minimum balance to create class **/ createClassDeposit: BalanceOf & AugmentedConst; /** * The minimum balance to create token **/ createTokenDeposit: BalanceOf & AugmentedConst; /** * The NFT's module id **/ palletId: PalletId & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; phragmenElection: { /** * How much should be locked up in order to submit one's candidacy. **/ candidacyBond: BalanceOf & AugmentedConst; /** * Number of members to elect. **/ desiredMembers: u32 & AugmentedConst; /** * Number of runners_up to keep. **/ desiredRunnersUp: u32 & AugmentedConst; /** * Identifier for the elections-phragmen pallet's lock **/ palletId: LockIdentifier & 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: BlockNumber & 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: BalanceOf & AugmentedConst; /** * The amount of bond that need to be locked for each vote (32 bytes). **/ votingBondFactor: BalanceOf & 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: BalanceOf & 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: BalanceOf & 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: u16 & 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: BalanceOf & 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: BalanceOf & 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: BalanceOf & 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: BalanceOf & AugmentedConst; /** * The maximum amount of friends allowed in a recovery configuration. **/ maxFriends: u16 & AugmentedConst; /** * The base amount of currency needed to reserve for starting a recovery. * * This is primarily held for deterring malicious recovery attempts, and should * have a value large enough that a bad actor would choose not to place this * deposit. It also acts to fund additional storage item whose value size is * `sizeof(BlockNumber, Balance + T * AccountId)` bytes. Where T is a configurable * threshold. **/ recoveryDeposit: BalanceOf & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; staking: { /** * Number of eras that staked funds must remain bonded for. **/ bondingDuration: EraIndex & AugmentedConst; /** * Maximum number of nominations per nominator. **/ maxNominations: u32 & AugmentedConst; /** * The maximum number of nominators rewarded for each validator. * * For each validator only the `$MaxNominatorRewardedPerValidator` biggest stakers can claim * their reward. This used to limit the i/o cost for the nominator payout. **/ maxNominatorRewardedPerValidator: u32 & AugmentedConst; /** * Number of sessions per era. **/ sessionsPerEra: SessionIndex & 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: EraIndex & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; system: { /** * Maximum number of block number to block hash mappings to keep (oldest pruned first). **/ blockHashCount: BlockNumber & AugmentedConst; /** * The maximum length of a block (in bytes). **/ blockLength: BlockLength & AugmentedConst; /** * Block & extrinsics weights: base values and limits. **/ blockWeights: BlockWeights & AugmentedConst; /** * The weight of runtime database operations the runtime can invoke. **/ dbWeight: RuntimeDbWeight & AugmentedConst; /** * The designated SS85 prefix of this chain. * * This replaces the "ss58Format" property declared in the chain spec. Reason is * that the runtime should know about the prefix in order to make use of it as * an identifier of the chain. **/ ss58Prefix: u8 & AugmentedConst; /** * Get the chain's current version. **/ version: RuntimeVersion & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; timestamp: { /** * The minimum period between blocks. Beware that this is different to the *expected* period * that the block production apparatus provides. Your chosen consensus system will generally * work with this to determine a sensible block time. e.g. For Aura, it will be double this * period on default settings. **/ minimumPeriod: Moment & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; tips: { /** * The amount held on deposit per byte within the tip report reason. **/ dataDepositPerByte: BalanceOf & AugmentedConst; /** * Maximum acceptable reason length. **/ maximumReasonLength: u32 & AugmentedConst; /** * The period for which a tip remains open after is has achieved threshold tippers. **/ tipCountdown: BlockNumber & AugmentedConst; /** * The amount of the final tip which goes to the original reporter of the tip. **/ tipFindersFee: Percent & AugmentedConst; /** * The amount held on deposit for placing a tip report. **/ tipReportDepositBase: BalanceOf & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; tokens: { palletId: PalletId & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; transactionPayment: { /** * The fee to be paid for making a transaction; the per-byte portion. **/ transactionByteFee: BalanceOf & AugmentedConst; /** * The polynomial that is applied in order to derive fee from weight. **/ weightToFee: Vec & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; treasury: { /** * Percentage of spare funds (if any) that are burnt per spend period. **/ burn: Permill & AugmentedConst; /** * The treasury's module id, used for deriving its sovereign account ID. **/ palletId: PalletId & AugmentedConst; /** * Fraction of a proposal's value that should be bonded in order to place the proposal. * An accepted proposal gets these back. A rejected proposal does not. **/ proposalBond: Permill & AugmentedConst; /** * Minimum amount of funds that should be placed in a deposit for making a proposal. **/ proposalBondMinimum: BalanceOf & AugmentedConst; /** * Period between successive spends. **/ spendPeriod: BlockNumber & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; vesting: { /** * The minimum amount transferred to call `vested_transfer`. **/ minVestedTransfer: BalanceOf & AugmentedConst; /** * Generic const **/ [key: string]: Codec; }; } interface QueryableConsts extends AugmentedConsts { [key: string]: QueryableModuleConsts; } }