@polkadot/api-augment 15.10.2 → 16.1.1

package/assetHubKusama/consts.d.ts

@@ -0,0 +1,613 @@
+import '@polkadot/api-base/types/consts';
+import type { ApiTypes, AugmentedConst } from '@polkadot/api-base/types';
+import type { Bytes, Option, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
+import type { Codec } from '@polkadot/types-codec/types';
+import type { Permill } from '@polkadot/types/interfaces/runtime';
+import type { FrameSupportPalletId, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion, SpWeightsRuntimeDbWeight, SpWeightsWeightV2Weight, StagingXcmV4Location } from '@polkadot/types/lookup';
+export type __AugmentedConst<ApiType extends ApiTypes> = AugmentedConst<ApiType>;
+declare module '@polkadot/api-base/types/consts' {
+    interface AugmentedConsts<ApiType extends ApiTypes> {
+        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: StagingXcmV4Location & 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;
+        };
+        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<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;
+        };
+        foreignAssets: {
+            /**
+             * 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;
+        };
+        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;
+        };
+        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;
+        };
+        parachainSystem: {
+            /**
+             * Returns the parachain ID we are running with.
+             **/
+            selfParaId: u32 & 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;
+        };
+        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;
+        };
+        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;
+        };
+        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;
+        };
+        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;
+        };
+        xcmpQueue: {
+            /**
+             * Maximal number of outbound XCMP channels that can have messages queued at the same time.
+             *
+             * If this is reached, then no further messages can be sent to channels that do not yet
+             * have a message queued. This should be set to the expected maximum of outbound channels
+             * which is determined by [`Self::ChannelInfo`]. It is important to set this large enough,
+             * since otherwise the congestion control protocol will not work as intended and messages
+             * may be dropped. This value increases the PoV and should therefore not be picked too
+             * high. Governance needs to pay attention to not open more channels than this value.
+             **/
+            maxActiveOutboundChannels: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximum number of inbound XCMP channels that can be suspended simultaneously.
+             *
+             * Any further channel suspensions will fail and messages may get dropped without further
+             * notice. Choosing a high value (1000) is okay; the trade-off that is described in
+             * [`InboundXcmpSuspended`] still applies at that scale.
+             **/
+            maxInboundSuspended: u32 & AugmentedConst<ApiType>;
+            /**
+             * The maximal page size for HRMP message pages.
+             *
+             * A lower limit can be set dynamically, but this is the hard-limit for the PoV worst case
+             * benchmarking. The limit for the size of a message is slightly below this, since some
+             * overhead is incurred for encoding the format.
+             **/
+            maxPageSize: u32 & AugmentedConst<ApiType>;
+            /**
+             * Generic const
+             **/
+            [key: string]: Codec;
+        };
+    }
+}

package/assetHubKusama/consts.js

@@ -0,0 +1,2 @@
+/* eslint-disable */
+import '@polkadot/api-base/types/consts';