@dedot/chaintypes 0.122.0 → 0.131.0

package/polkadot/runtime.d.ts

@@ -53,6 +53,7 @@ import type {
   PolkadotPrimitivesV8AsyncBackingAsyncBackingParams,
   PolkadotPrimitivesV8ApprovalVotingParams,
   PolkadotPrimitivesV8CoreIndex,
+  PolkadotPrimitivesVstagingAsyncBackingConstraints,
   SpConsensusBeefyValidatorSet,
   SpConsensusBeefyDoubleVotingProof,
   SpRuntimeOpaqueValue,
@@ -803,6 +804,27 @@ export interface RuntimeApis<Rv extends RpcVersion> extends GenericRuntimeApis<R
      **/
     validationCodeBombLimit: GenericRuntimeApiMethod<Rv, () => Promise<number>>;
 
+    /**
+     * Returns the constraints on the actions that can be taken by a new parachain
+     * block.
+     *
+     * @callname: ParachainHost_backing_constraints
+     * @param {PolkadotParachainPrimitivesPrimitivesId} para_id
+     **/
+    backingConstraints: GenericRuntimeApiMethod<
+      Rv,
+      (
+        paraId: PolkadotParachainPrimitivesPrimitivesId,
+      ) => Promise<PolkadotPrimitivesVstagingAsyncBackingConstraints | undefined>
+    >;
+
+    /**
+     * Retrieve the scheduling lookahead
+     *
+     * @callname: ParachainHost_scheduling_lookahead
+     **/
+    schedulingLookahead: GenericRuntimeApiMethod<Rv, () => Promise<number>>;
+
     /**
      * Generic runtime api call
      **/

package/polkadot/tx.d.ts

@@ -77,7 +77,7 @@ import type {
   PolkadotPrimitivesV8PvfCheckStatement,
   PolkadotPrimitivesV8ValidatorAppSignature,
   PolkadotParachainPrimitivesPrimitivesHrmpChannelId,
-  PolkadotPrimitivesV8SlashingDisputeProof,
+  PolkadotPrimitivesVstagingDisputeProof,
   SpRuntimeMultiSigner,
   PalletBrokerCoretimeInterfaceCoreAssignment,
   PolkadotRuntimeParachainsAssignerCoretimePartsOf57600,
@@ -744,7 +744,7 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
     >;
 
     /**
-     * Ensure that the a bulk of pre-images is upgraded.
+     * Ensure that the bulk of pre-images is upgraded.
      *
      * The caller pays no fee if at least 90% of pre-images were successfully updated.
      *
@@ -1067,6 +1067,34 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Poke the deposit reserved for an index.
+     *
+     * The dispatch origin for this call must be _Signed_ and the signing account must have a
+     * non-frozen account `index`.
+     *
+     * The transaction fees is waived if the deposit is changed after poking/reconsideration.
+     *
+     * - `index`: the index whose deposit is to be poked/reconsidered.
+     *
+     * Emits `DepositPoked` if successful.
+     *
+     * @param {number} index
+     **/
+    pokeDeposit: GenericTxCall<
+      Rv,
+      (index: number) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Indices';
+          palletCall: {
+            name: 'PokeDeposit';
+            params: { index: number };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -2264,29 +2292,75 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
     >;
 
     /**
-     * Adjusts the staking ledger by withdrawing any excess staked amount.
+     * Removes the legacy Staking locks if they exist.
+     *
+     * This removes the legacy lock on the stake with [`Config::OldCurrency`] and creates a
+     * hold on it if needed. If all stake cannot be held, the best effort is made to hold as
+     * much as possible. The remaining stake is forced withdrawn from the ledger.
      *
-     * This function corrects cases where a user's recorded stake in the ledger
-     * exceeds their actual staked funds. This situation can arise due to cases such as
-     * external slashing by another pallet, leading to an inconsistency between the ledger
-     * and the actual stake.
+     * The fee is waived if the migration is successful.
      *
      * @param {AccountId32Like} stash
      **/
-    withdrawOverstake: GenericTxCall<
+    migrateCurrency: GenericTxCall<
       Rv,
       (stash: AccountId32Like) => ChainSubmittableExtrinsic<
         Rv,
         {
           pallet: 'Staking';
           palletCall: {
-            name: 'WithdrawOverstake';
+            name: 'MigrateCurrency';
             params: { stash: AccountId32Like };
           };
         }
       >
     >;
 
+    /**
+     * This function allows governance to manually slash a validator and is a
+     * **fallback mechanism**.
+     *
+     * The dispatch origin must be `T::AdminOrigin`.
+     *
+     * ## Parameters
+     * - `validator_stash` - The stash account of the validator to slash.
+     * - `era` - The era in which the validator was in the active set.
+     * - `slash_fraction` - The percentage of the stake to slash, expressed as a Perbill.
+     *
+     * ## Behavior
+     *
+     * The slash will be applied using the standard slashing mechanics, respecting the
+     * configured `SlashDeferDuration`.
+     *
+     * This means:
+     * - If the validator was already slashed by a higher percentage for the same era, this
+     * slash will have no additional effect.
+     * - If the validator was previously slashed by a lower percentage, only the difference
+     * will be applied.
+     * - The slash will be deferred by `SlashDeferDuration` eras before being enacted.
+     *
+     * @param {AccountId32Like} validatorStash
+     * @param {number} era
+     * @param {Perbill} slashFraction
+     **/
+    manualSlash: GenericTxCall<
+      Rv,
+      (
+        validatorStash: AccountId32Like,
+        era: number,
+        slashFraction: Perbill,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Staking';
+          palletCall: {
+            name: 'ManualSlash';
+            params: { validatorStash: AccountId32Like; era: number; slashFraction: Perbill };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -3912,6 +3986,78 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Dispatch a fallback call in the event the main call fails to execute.
+     * May be called from any origin except `None`.
+     *
+     * This function first attempts to dispatch the `main` call.
+     * If the `main` call fails, the `fallback` is attemted.
+     * if the fallback is successfully dispatched, the weights of both calls
+     * are accumulated and an event containing the main call error is deposited.
+     *
+     * In the event of a fallback failure the whole call fails
+     * with the weights returned.
+     *
+     * - `main`: The main call to be dispatched. This is the primary action to execute.
+     * - `fallback`: The fallback call to be dispatched in case the `main` call fails.
+     *
+     * ## Dispatch Logic
+     * - If the origin is `root`, both the main and fallback calls are executed without
+     * applying any origin filters.
+     * - If the origin is not `root`, the origin filter is applied to both the `main` and
+     * `fallback` calls.
+     *
+     * ## Use Case
+     * - Some use cases might involve submitting a `batch` type call in either main, fallback
+     * or both.
+     *
+     * @param {PolkadotRuntimeRuntimeCallLike} main
+     * @param {PolkadotRuntimeRuntimeCallLike} fallback
+     **/
+    ifElse: GenericTxCall<
+      Rv,
+      (
+        main: PolkadotRuntimeRuntimeCallLike,
+        fallback: PolkadotRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Utility';
+          palletCall: {
+            name: 'IfElse';
+            params: { main: PolkadotRuntimeRuntimeCallLike; fallback: PolkadotRuntimeRuntimeCallLike };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Dispatches a function call with a provided origin.
+     *
+     * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call.
+     *
+     * The dispatch origin for this call must be _Root_.
+     *
+     * @param {PolkadotRuntimeOriginCaller} asOrigin
+     * @param {PolkadotRuntimeRuntimeCallLike} call
+     **/
+    dispatchAsFallible: GenericTxCall<
+      Rv,
+      (
+        asOrigin: PolkadotRuntimeOriginCaller,
+        call: PolkadotRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Utility';
+          palletCall: {
+            name: 'DispatchAsFallible';
+            params: { asOrigin: PolkadotRuntimeOriginCaller; call: PolkadotRuntimeRuntimeCallLike };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -4279,6 +4425,30 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Poke / Adjust deposits made for proxies and announcements based on current values.
+     * This can be used by accounts to possibly lower their locked amount.
+     *
+     * The dispatch origin for this call must be _Signed_.
+     *
+     * The transaction fee is waived if the deposit amount has changed.
+     *
+     * Emits `DepositPoked` if successful.
+     *
+     **/
+    pokeDeposit: GenericTxCall<
+      Rv,
+      () => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Proxy';
+          palletCall: {
+            name: 'PokeDeposit';
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -4511,6 +4681,43 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Poke the deposit reserved for an existing multisig operation.
+     *
+     * The dispatch origin for this call must be _Signed_ and must be the original depositor of
+     * the multisig operation.
+     *
+     * The transaction fee is waived if the deposit amount has changed.
+     *
+     * - `threshold`: The total number of approvals needed for this multisig.
+     * - `other_signatories`: The accounts (other than the sender) who are part of the
+     * multisig.
+     * - `call_hash`: The hash of the call this deposit is reserved for.
+     *
+     * Emits `DepositPoked` if successful.
+     *
+     * @param {number} threshold
+     * @param {Array<AccountId32Like>} otherSignatories
+     * @param {FixedBytes<32>} callHash
+     **/
+    pokeDeposit: GenericTxCall<
+      Rv,
+      (
+        threshold: number,
+        otherSignatories: Array<AccountId32Like>,
+        callHash: FixedBytes<32>,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Multisig';
+          palletCall: {
+            name: 'PokeDeposit';
+            params: { threshold: number; otherSignatories: Array<AccountId32Like>; callHash: FixedBytes<32> };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -5383,8 +5590,9 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
    **/
   nominationPools: {
     /**
-     * Stake funds with a pool. The amount to bond is transferred from the member to the pool
-     * account and immediately increases the pools bond.
+     * Stake funds with a pool. The amount to bond is delegated (or transferred based on
+     * [`adapter::StakeStrategyType`]) from the member to the pool account and immediately
+     * increases the pool's bond.
      *
      * The method of transferring the amount to the pool account is determined by
      * [`adapter::StakeStrategyType`]. If the pool is configured to use
@@ -5682,13 +5890,13 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      * The dispatch origin of this call must be signed by the pool nominator or the pool
      * root role.
      *
-     * This directly forward the call to the staking pallet, on behalf of the pool bonded
-     * account.
+     * This directly forwards the call to an implementation of `StakingInterface` (e.g.,
+     * `pallet-staking`) through [`Config::StakeAdapter`], on behalf of the bonded pool.
      *
      * # Note
      *
-     * In addition to a `root` or `nominator` role of `origin`, pool's depositor needs to have
-     * at least `depositor_min_bond` in the pool to start nominating.
+     * In addition to a `root` or `nominator` role of `origin`, the pool's depositor needs to
+     * have at least `depositor_min_bond` in the pool to start nominating.
      *
      * @param {number} poolId
      * @param {Array<AccountId32Like>} validators
@@ -5860,6 +6068,9 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      * The dispatch origin of this call can be signed by the pool nominator or the pool
      * root role, same as [`Pallet::nominate`].
      *
+     * This directly forwards the call to an implementation of `StakingInterface` (e.g.,
+     * `pallet-staking`) through [`Config::StakeAdapter`], on behalf of the bonded pool.
+     *
      * Under certain conditions, this call can be dispatched permissionlessly (i.e. by any
      * account).
      *
@@ -5868,9 +6079,7 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      * are unable to unbond.
      *
      * # Conditions for permissioned dispatch:
-     * * The caller has a nominator or root role of the pool.
-     * This directly forward the call to the staking pallet, on behalf of the pool bonded
-     * account.
+     * * The caller is the pool's nominator or root.
      *
      * @param {number} poolId
      **/
@@ -6049,9 +6258,20 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
     /**
      * Claim pending commission.
      *
-     * The dispatch origin of this call must be signed by the `root` role of the pool. Pending
-     * commission is paid out and added to total claimed commission`. Total pending commission
-     * is reset to zero. the current.
+     * The `root` role of the pool is _always_ allowed to claim the pool's commission.
+     *
+     * If the pool has set `CommissionClaimPermission::Permissionless`, then any account can
+     * trigger the process of claiming the pool's commission.
+     *
+     * If the pool has set its `CommissionClaimPermission` to `Account(acc)`, then only
+     * accounts
+     * * `acc`, and
+     * * the pool's root account
+     *
+     * may call this extrinsic on behalf of the pool.
+     *
+     * Pending commissions are paid out and added to the total claimed commission.
+     * The total pending commission is reset to zero.
      *
      * @param {number} poolId
      **/
@@ -7904,13 +8124,13 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
   parasSlashing: {
     /**
      *
-     * @param {PolkadotPrimitivesV8SlashingDisputeProof} disputeProof
+     * @param {PolkadotPrimitivesVstagingDisputeProof} disputeProof
      * @param {SpSessionMembershipProof} keyOwnerProof
      **/
     reportDisputeLostUnsigned: GenericTxCall<
       Rv,
       (
-        disputeProof: PolkadotPrimitivesV8SlashingDisputeProof,
+        disputeProof: PolkadotPrimitivesVstagingDisputeProof,
         keyOwnerProof: SpSessionMembershipProof,
       ) => ChainSubmittableExtrinsic<
         Rv,
@@ -7918,7 +8138,7 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
           pallet: 'ParasSlashing';
           palletCall: {
             name: 'ReportDisputeLostUnsigned';
-            params: { disputeProof: PolkadotPrimitivesV8SlashingDisputeProof; keyOwnerProof: SpSessionMembershipProof };
+            params: { disputeProof: PolkadotPrimitivesVstagingDisputeProof; keyOwnerProof: SpSessionMembershipProof };
           };
         }
       >
@@ -8007,6 +8227,45 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Create a single on demand core order with credits.
+     * Will charge the owner's on-demand credit account the spot price for the current block.
+     *
+     * Parameters:
+     * - `origin`: The sender of the call, on-demand credits will be withdrawn from this
+     * account.
+     * - `max_amount`: The maximum number of credits to spend from the origin to place an
+     * order.
+     * - `para_id`: A `ParaId` the origin wants to provide blockspace for.
+     *
+     * Errors:
+     * - `InsufficientCredits`
+     * - `QueueFull`
+     * - `SpotPriceHigherThanMaxAmount`
+     *
+     * Events:
+     * - `OnDemandOrderPlaced`
+     *
+     * @param {bigint} maxAmount
+     * @param {PolkadotParachainPrimitivesPrimitivesId} paraId
+     **/
+    placeOrderWithCredits: GenericTxCall<
+      Rv,
+      (
+        maxAmount: bigint,
+        paraId: PolkadotParachainPrimitivesPrimitivesId,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'OnDemand';
+          palletCall: {
+            name: 'PlaceOrderWithCredits';
+            params: { maxAmount: bigint; paraId: PolkadotParachainPrimitivesPrimitivesId };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -8829,6 +9088,28 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     *
+     * @param {AccountId32Like} who
+     * @param {bigint} amount
+     **/
+    creditAccount: GenericTxCall<
+      Rv,
+      (
+        who: AccountId32Like,
+        amount: bigint,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Coretime';
+          palletCall: {
+            name: 'CreditAccount';
+            params: { who: AccountId32Like; amount: bigint };
+          };
+        }
+      >
+    >;
+
     /**
      * Receive instructions from the `ExternalBrokerOrigin`, detailing how a specific core is
      * to be used.
@@ -9647,6 +9928,77 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Authorize another `aliaser` location to alias into the local `origin` making this call.
+     * The `aliaser` is only authorized until the provided `expiry` block number.
+     * The call can also be used for a previously authorized alias in order to update its
+     * `expiry` block number.
+     *
+     * Usually useful to allow your local account to be aliased into from a remote location
+     * also under your control (like your account on another chain).
+     *
+     * WARNING: make sure the caller `origin` (you) trusts the `aliaser` location to act in
+     * their/your name. Once authorized using this call, the `aliaser` can freely impersonate
+     * `origin` in XCM programs executed on the local chain.
+     *
+     * @param {XcmVersionedLocation} aliaser
+     * @param {bigint | undefined} expires
+     **/
+    addAuthorizedAlias: GenericTxCall<
+      Rv,
+      (
+        aliaser: XcmVersionedLocation,
+        expires: bigint | undefined,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmPallet';
+          palletCall: {
+            name: 'AddAuthorizedAlias';
+            params: { aliaser: XcmVersionedLocation; expires: bigint | undefined };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Remove a previously authorized `aliaser` from the list of locations that can alias into
+     * the local `origin` making this call.
+     *
+     * @param {XcmVersionedLocation} aliaser
+     **/
+    removeAuthorizedAlias: GenericTxCall<
+      Rv,
+      (aliaser: XcmVersionedLocation) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmPallet';
+          palletCall: {
+            name: 'RemoveAuthorizedAlias';
+            params: { aliaser: XcmVersionedLocation };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Remove all previously authorized `aliaser`s that can alias into the local `origin`
+     * making this call.
+     *
+     **/
+    removeAllAuthorizedAliases: GenericTxCall<
+      Rv,
+      () => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmPallet';
+          palletCall: {
+            name: 'RemoveAllAuthorizedAliases';
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/