@argonprotocol/mainchain 1.4.3-dev.43df9563 → 1.4.3-dev.4544e954

package/src/interfaces/augment-api-consts.ts

@@ -0,0 +1,655 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+
+// import type lookup before we augment - in some environments
+// this is required to allow for ambient/previous definitions
+import type {} from '@polkadot/api-base/types/consts';
+
+import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types';
+import type { u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
+import type { ITuple } from '@polkadot/types-codec/types';
+import type { AccountId32, Percent } from '@polkadot/types/interfaces/runtime';
+import type {
+  FrameSupportPalletId,
+  FrameSystemLimitsBlockLength,
+  FrameSystemLimitsBlockWeights,
+  SpVersionRuntimeVersion,
+  SpWeightsRuntimeDbWeight,
+} from '@polkadot/types/lookup';
+
+export type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;
+
+declare module '@polkadot/api-base/types/consts' {
+  interface AugmentedConsts<ApiType extends ApiTypes> {
+    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>;
+    };
+    bitcoinLocks: {
+      /**
+       * Argon tick per day
+       **/
+      argonTicksPerDay: u64 & AugmentedConst<ApiType>;
+      /**
+       * The number of bitcoin blocks a bitcoin is locked for
+       **/
+      lockDurationBlocks: u64 & AugmentedConst<ApiType>;
+      /**
+       * The bitcoin blocks after a BitcoinLock expires which the vault will be allowed to claim
+       * a bitcoin
+       **/
+      lockReclamationBlocks: u64 & AugmentedConst<ApiType>;
+      /**
+       * Number of frames a vault has to counter-sign a bitcoin release
+       **/
+      lockReleaseCosignDeadlineFrames: u64 & AugmentedConst<ApiType>;
+      /**
+       * Max allowed tick-age of microgon-per-btc prices
+       **/
+      maxBtcPriceTickAge: u32 & AugmentedConst<ApiType>;
+      /**
+       * Pallet storage requires bounds, so we have to set a maximum number that can expire in a
+       * single block
+       **/
+      maxConcurrentlyExpiringLocks: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum releasing utxos at a time
+       **/
+      maxConcurrentlyReleasingLocks: u32 & AugmentedConst<ApiType>;
+      /**
+       * Number of frames orphaned UTXO release entries are retained after a lock lifecycle
+       * transition before being cleaned up.
+       **/
+      orphanedUtxoReleaseExpiryFrames: u64 & AugmentedConst<ApiType>;
+      /**
+       * Number of ticks per bitcoin block
+       **/
+      ticksPerBitcoinBlock: u64 & AugmentedConst<ApiType>;
+    };
+    bitcoinUtxos: {
+      /**
+       * Maximum number of candidate UTXOs stored per lock
+       **/
+      maxCandidateUtxosPerLock: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of satoshi difference allowed from expected to consider a UTXO as
+       * "confirmed"
+       **/
+      maximumSatoshiThresholdFromExpected: u64 & AugmentedConst<ApiType>;
+      /**
+       * Maximum bitcoin blocks to watch a Utxo for confirmation before canceling
+       **/
+      maxPendingConfirmationBlocks: u64 & AugmentedConst<ApiType>;
+      /**
+       * The maximum number of UTXOs that can be watched in a block and/or expiring at same block
+       **/
+      maxPendingConfirmationUtxos: u32 & AugmentedConst<ApiType>;
+      /**
+       * The maximum number of expired pending funding entries cleaned up in a block
+       **/
+      maxPendingFundingExpirationsPerBlock: u32 & AugmentedConst<ApiType>;
+    };
+    blockRewards: {
+      /**
+       * The tick number at which the halving begins for ownership tokens
+       **/
+      halvingBeginTicks: u64 & AugmentedConst<ApiType>;
+      /**
+       * Number of ticks for halving of ownership share rewards
+       **/
+      halvingTicks: u64 & AugmentedConst<ApiType>;
+      /**
+       * The growth path for both ownership and argons before halving
+       **/
+      incrementalGrowth: ITuple<[u128, u64, u128]> & AugmentedConst<ApiType>;
+      /**
+       * Percent as a number out of 100 of the block reward that goes to the miner.
+       **/
+      minerPayoutPercent: u128 & AugmentedConst<ApiType>;
+      /**
+       * Number of argons minted per block
+       **/
+      startingArgonsPerBlock: u128 & AugmentedConst<ApiType>;
+      /**
+       * Number of ownership tokens minted per block
+       **/
+      startingOwnershipTokensPerBlock: u128 & AugmentedConst<ApiType>;
+    };
+    blockSealSpec: {
+      /**
+       * The number of historical compute times to use to calculate the rolling compute average
+       * (for adjustment)
+       **/
+      historicalComputeBlocksForAverage: u32 & AugmentedConst<ApiType>;
+      /**
+       * The number of historical vote blocks to use to calculate the rolling vote average
+       **/
+      historicalVoteBlocksForAverage: u32 & AugmentedConst<ApiType>;
+      /**
+       * The maximum active notaries allowed
+       **/
+      maxActiveNotaries: u32 & AugmentedConst<ApiType>;
+      /**
+       * The desired votes per block
+       **/
+      targetBlockVotes: u128 & AugmentedConst<ApiType>;
+    };
+    crosschainTransfer: {
+      /**
+       * Minimum remaining frame commitment required when reading vault committed collateral
+       * capacity for council weighting and Minting Authority collateral.
+       **/
+      councilRotationFrames: u64 & AugmentedConst<ApiType>;
+      /**
+       * Default minimum normalized microgon value required to register a Minting Authority on
+       * one destination chain.
+       **/
+      defaultMinimumMintingAuthorityMicrogonValue: u128 & AugmentedConst<ApiType>;
+      /**
+       * Canonical Ethereum burn-accounting account representing funds moved to Ethereum.
+       **/
+      ethereumBurnAccount: AccountId32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of ordered gateway activities that may share one receipt proof.
+       **/
+      maxActivitiesPerReceiptProof: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of members the active Global Issuance Council may carry.
+       **/
+      maxCouncilMembers: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of non-terminal transfer-out requests tracked for one destination chain.
+       **/
+      maxPendingTransferOutsPerDestinationChain: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum execution headers carried in one receipt proof's target-to-anchor chain.
+       **/
+      maxProofExecutionHeaderDepth: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of contiguous queue approvals one council member may submit in one call.
+       **/
+      maxQueueApprovalsPerCall: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of proven receipt proofs that may be supplied in one extrinsic.
+       **/
+      maxReceiptProofsPerExtrinsic: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum age, in ticks, of the verified Ethereum execution anchor used to open a
+       * transfer out.
+       **/
+      maxVerifiedExecutionBlockAgeTicks: u64 & AugmentedConst<ApiType>;
+      /**
+       * Minimum normalized collateral increment accepted for one transfer unless the increment
+       * completes the remaining uncovered amount.
+       **/
+      minTransferCollateralIncrement: u128 & AugmentedConst<ApiType>;
+      /**
+       * Retention window, in ticks, for recent Argon transfer evidence used by operational
+       * accounts.
+       **/
+      recentTransferRetentionTicks: u64 & AugmentedConst<ApiType>;
+      /**
+       * Minting authority tip rate applied to transfer-out requests in basis points.
+       **/
+      transferOutMintingAuthorityTipBasisPoints: u32 & AugmentedConst<ApiType>;
+      /**
+       * Ethereum-block window added to the latest verified block when opening a
+       * transfer out.
+       **/
+      transferOutValidityEthereumBlocks: u64 & AugmentedConst<ApiType>;
+    };
+    ethereumVerifier: {
+      /**
+       * Minimum gap between finalized headers for an update to be free.
+       **/
+      freeHeadersInterval: u32 & AugmentedConst<ApiType>;
+    };
+    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>;
+    };
+    localchainTransfer: {
+      /**
+       * How many transfers out can be queued per block
+       **/
+      maxPendingTransfersOutPerBlock: u32 & AugmentedConst<ApiType>;
+      palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+      /**
+       * How long a transfer should remain in storage before returning. NOTE: there is a 2 tick
+       * grace period where we will still allow a transfer
+       **/
+      transferExpirationTicks: u64 & AugmentedConst<ApiType>;
+    };
+    miningSlot: {
+      /**
+       * The max percent swing for the argonots per slot (from the last percent)
+       **/
+      argonotsPercentAdjustmentDamper: u128 & AugmentedConst<ApiType>;
+      /**
+       * The increment that bids can be on (for instance, one cent increments)
+       **/
+      bidIncrements: u128 & AugmentedConst<ApiType>;
+      /**
+       * The number of frames a miner operates for
+       **/
+      framesPerMiningTerm: u32 & AugmentedConst<ApiType>;
+      /**
+       * How many new miners can be in the cohort for each slot. The actual maximum will adjust
+       * dynamically
+       **/
+      maxCohortSize: u32 & AugmentedConst<ApiType>;
+      /**
+       * The maximum percent of argonots in the network that should be required for
+       * mining seats
+       **/
+      maximumArgonotProrataPercent: Percent & AugmentedConst<ApiType>;
+      /**
+       * The minimum number of miners per cohort
+       **/
+      minCohortSize: u32 & AugmentedConst<ApiType>;
+      /**
+       * The minimum argonots needed per seat
+       **/
+      minimumArgonotsPerSeat: u128 & AugmentedConst<ApiType>;
+      /**
+       * Account that receives mining bid funds before treasury distribution.
+       **/
+      miningBidPoolAccount: AccountId32 & AugmentedConst<ApiType>;
+      /**
+       * The damper on the price per seat adjustment (from the last price)
+       **/
+      pricePerSeatAdjustmentDamper: u128 & AugmentedConst<ApiType>;
+      /**
+       * The target percent of bids per auction relative to the max number of seats. This will
+       * adjust the argonots per seat up or down to ensure mining slots are filled.
+       **/
+      targetBidsPerSeatPercent: u128 & AugmentedConst<ApiType>;
+      /**
+       * The target price per seat.
+       **/
+      targetPricePerSeat: u128 & AugmentedConst<ApiType>;
+    };
+    mint: {
+      /**
+       * The maximum number of mint histories to keep
+       **/
+      maxMintHistoryToMaintain: u32 & AugmentedConst<ApiType>;
+      /**
+       * The maximum number of UTXOs that can be waiting for minting
+       **/
+      maxPendingMintUtxos: u32 & AugmentedConst<ApiType>;
+      maxPossibleMiners: u32 & AugmentedConst<ApiType>;
+    };
+    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>;
+    };
+    notaries: {
+      /**
+       * The maximum active notaries allowed
+       **/
+      maxActiveNotaries: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum hosts a notary can supply
+       **/
+      maxNotaryHosts: u32 & AugmentedConst<ApiType>;
+      /**
+       * The maximum blocks a proposal can sit unapproved
+       **/
+      maxProposalHoldBlocks: u32 & AugmentedConst<ApiType>;
+      maxProposalsPerBlock: u32 & AugmentedConst<ApiType>;
+      /**
+       * Number of ticks to maintain key history for each notary
+       * NOTE: only pruned when new keys are added
+       **/
+      maxTicksForKeyHistory: u32 & AugmentedConst<ApiType>;
+      /**
+       * Number of ticks to delay changing a notaries' meta (this is to allow a window for
+       * notaries to switch to new keys after a new key is finalized)
+       **/
+      metaChangesTickDelay: u64 & AugmentedConst<ApiType>;
+    };
+    operationalAccounts: {
+      /**
+       * Additional argon amount (base units) required per referral after operational.
+       **/
+      bitcoinLockSizeForReferral: u128 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of available referrals allowed at once.
+       **/
+      maxAvailableReferrals: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of encrypted server bytes stored per sponsee.
+       **/
+      maxEncryptedServerLen: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of expired referral codes cleared per block.
+       **/
+      maxExpiredReferralCodeCleanupsPerBlock: u32 & AugmentedConst<ApiType>;
+      /**
+       * Mining seats required to become operational.
+       **/
+      miningSeatsForOperational: u32 & AugmentedConst<ApiType>;
+      /**
+       * Mining seats required per referral after operational.
+       **/
+      miningSeatsPerReferral: u32 & AugmentedConst<ApiType>;
+      /**
+       * Minimum vault securitization required to become operational.
+       **/
+      operationalMinimumVaultSecuritization: u128 & AugmentedConst<ApiType>;
+      /**
+       * Default bonus reward paid every referral threshold.
+       **/
+      operationalReferralBonusReward: u128 & AugmentedConst<ApiType>;
+      /**
+       * Default reward paid when an account becomes operational.
+       **/
+      operationalReferralReward: u128 & AugmentedConst<ApiType>;
+      /**
+       * Number of operational sponsees required per referral bonus reward.
+       **/
+      referralBonusEveryXOperationalSponsees: u32 & AugmentedConst<ApiType>;
+    };
+    ownership: {
+      /**
+       * 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>;
+    };
+    priceIndex: {
+      /**
+       * The max price difference dropping below target or raising above target per tick. There's
+       * no corresponding constant for time to recovery to target
+       **/
+      maxArgonChangePerTickAwayFromTarget: u128 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of per-frame Argonot floor buckets to retain.
+       **/
+      maxArgonotFloorHistoryFrames: u32 & AugmentedConst<ApiType>;
+      maxArgonTargetChangePerTick: u128 & AugmentedConst<ApiType>;
+      /**
+       * The maximum number of ticks to preserve a price index
+       **/
+      maxDowntimeTicksBeforeReset: u64 & AugmentedConst<ApiType>;
+      /**
+       * The oldest history to keep
+       **/
+      maxPriceAgeInTicks: u64 & AugmentedConst<ApiType>;
+    };
+    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>;
+    };
+    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>;
+    };
+    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>;
+    };
+    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>;
+    };
+    treasury: {
+      /**
+       * The maximum number of bond lots whose release delay may mature in a single frame.
+       **/
+      maxPendingUnlocksPerFrame: u32 & AugmentedConst<ApiType>;
+      /**
+       * The maximum number of accepted bond lots in a vault's accepted bond-lot list.
+       **/
+      maxTreasuryContributors: u32 & AugmentedConst<ApiType>;
+      /**
+       * The maximum number of vaults that can participate in one frame's locked vault capital.
+       **/
+      maxVaultsPerPool: u32 & AugmentedConst<ApiType>;
+      /**
+       * The minimum whole-bond purchase amount.
+       **/
+      minimumArgonsPerContributor: u128 & AugmentedConst<ApiType>;
+      /**
+       * Treasury pallet id retained in metadata for account derivation.
+       **/
+      palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+      /**
+       * Percent of the bid pool reserved for treasury reserves.
+       **/
+      percentForTreasuryReserves: Percent & AugmentedConst<ApiType>;
+      /**
+       * The number of frames a releasing bond lot remains held before release.
+       **/
+      treasuryExitDelayFrames: u64 & AugmentedConst<ApiType>;
+      /**
+       * Account that holds treasury reserves for claims and reserve-funded payouts.
+       **/
+      treasuryReservesAccount: AccountId32 & AugmentedConst<ApiType>;
+    };
+    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>;
+    };
+    utility: {
+      /**
+       * The limit on the number of batched calls.
+       **/
+      batchedCallsLimit: u32 & AugmentedConst<ApiType>;
+    };
+    vaults: {
+      /**
+       * One no-fee stale `initialize_for` failure is allowed for each this-many units of lost
+       * `available_for_lock`.
+       **/
+      capacityDropAttemptUnit: u128 & AugmentedConst<ApiType>;
+      /**
+       * Max concurrent cosigns pending per vault
+       **/
+      maxPendingCosignsPerVault: u32 & AugmentedConst<ApiType>;
+      /**
+       * The max pending vault term changes per block
+       **/
+      maxPendingTermModificationsPerTick: u32 & AugmentedConst<ApiType>;
+      /**
+       * Maximum number of recent `available_for_lock` drops retained per vault.
+       **/
+      maxRecentCapacityDropsPerVault: u32 & AugmentedConst<ApiType>;
+      /**
+       * The max number of vaults that can be created
+       **/
+      maxVaults: u32 & AugmentedConst<ApiType>;
+      /**
+       * Duration to keep the operational minimum securitization locked from vault creation.
+       **/
+      operationalMinimumVaultLockTicks: u64 & AugmentedConst<ApiType>;
+      /**
+       * Minimum vault securitization required while the operational floor lock is active.
+       **/
+      operationalMinimumVaultSecuritization: u128 & AugmentedConst<ApiType>;
+      /**
+       * Number of Argon blocks to keep recent `available_for_lock` drops for stale init checks.
+       **/
+      recentCapacityDropBlockWindow: u32 & AugmentedConst<ApiType>;
+      /**
+       * The number of frames within which revenue must be collected
+       **/
+      revenueCollectionExpirationFrames: u64 & AugmentedConst<ApiType>;
+    };
+  } // AugmentedConsts
+} // declare module