@dedot/chaintypes 0.69.0 → 0.70.0

package/kusama-asset-hub/consts.d.ts

@@ -458,6 +458,15 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     [name: string]: any;
   };
+  /**
+   * Pallet `RemoteProxyRelayChain`'s constants
+   **/
+  remoteProxyRelayChain: {
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
   /**
    * Pallet `Assets`'s constants
    **/
@@ -806,6 +815,40 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     palletId: FrameSupportPalletId;
 
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s constants
+   **/
+  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: number;
+
     /**
      * Generic pallet constant
      **/

package/kusama-asset-hub/errors.d.ts

@@ -711,6 +711,50 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     [error: string]: GenericPalletError<Rv>;
   };
+  /**
+   * Pallet `RemoteProxyRelayChain`'s errors
+   **/
+  remoteProxyRelayChain: {
+    /**
+     * The local account id could not converted to the remote account id.
+     **/
+    CouldNotConvertLocalToRemoteAccountId: GenericPalletError<Rv>;
+
+    /**
+     * The anchor block of the remote proof is unknown.
+     **/
+    UnknownProofAnchorBlock: GenericPalletError<Rv>;
+
+    /**
+     * The proxy definition could not be found in the proof.
+     **/
+    InvalidProof: GenericPalletError<Rv>;
+
+    /**
+     * Failed to decode the remote proxy definition from the proof.
+     **/
+    ProxyDefinitionDecodingFailed: GenericPalletError<Rv>;
+
+    /**
+     * Announcement, if made at all, was made too recently.
+     **/
+    Unannounced: GenericPalletError<Rv>;
+
+    /**
+     * Could not find any matching proxy definition in the proof.
+     **/
+    DidNotFindMatchingProxyDefinition: GenericPalletError<Rv>;
+
+    /**
+     * Proxy proof not registered.
+     **/
+    ProxyProofNotRegistered: GenericPalletError<Rv>;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
   /**
    * Pallet `Assets`'s errors
    **/
@@ -1546,6 +1590,51 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     BelowMinimum: GenericPalletError<Rv>;
 
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s errors
+   **/
+  stateTrieMigration: {
+    /**
+     * Max signed limits not respected.
+     **/
+    MaxSignedLimits: GenericPalletError<Rv>;
+
+    /**
+     * A key was longer than the configured maximum.
+     *
+     * This means that the migration halted at the current [`Progress`] and
+     * can be resumed with a larger [`crate::Config::MaxKeyLen`] value.
+     * Retrying with the same [`crate::Config::MaxKeyLen`] value will not work.
+     * The value should only be increased to avoid a storage migration for the currently
+     * stored [`crate::Progress::LastKey`].
+     **/
+    KeyTooLong: GenericPalletError<Rv>;
+
+    /**
+     * submitter does not have enough funds.
+     **/
+    NotEnoughFunds: GenericPalletError<Rv>;
+
+    /**
+     * Bad witness data provided.
+     **/
+    BadWitness: GenericPalletError<Rv>;
+
+    /**
+     * Signed migration is not allowed because the maximum limit is not set yet.
+     **/
+    SignedMigrationNotAllowed: GenericPalletError<Rv>;
+
+    /**
+     * Bad child root provided.
+     **/
+    BadChildRoot: GenericPalletError<Rv>;
+
     /**
      * Generic pallet error
      **/

package/kusama-asset-hub/events.d.ts

@@ -30,6 +30,8 @@ import type {
   PalletNftsAttributeNamespace,
   PalletNftsPriceWithDirection,
   PalletNftsPalletAttributes,
+  PalletStateTrieMigrationMigrationCompute,
+  PalletStateTrieMigrationError,
 } from './types';
 
 export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
@@ -2502,6 +2504,41 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
 
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s events
+   **/
+  stateTrieMigration: {
+    /**
+     * Given number of `(top, child)` keys were migrated respectively, with the given
+     * `compute`.
+     **/
+    Migrated: GenericPalletEvent<
+      Rv,
+      'StateTrieMigration',
+      'Migrated',
+      { top: number; child: number; compute: PalletStateTrieMigrationMigrationCompute }
+    >;
+
+    /**
+     * Some account got slashed by the given amount.
+     **/
+    Slashed: GenericPalletEvent<Rv, 'StateTrieMigration', 'Slashed', { who: AccountId32; amount: bigint }>;
+
+    /**
+     * The auto migration task finished.
+     **/
+    AutoMigrationFinished: GenericPalletEvent<Rv, 'StateTrieMigration', 'AutoMigrationFinished', null>;
+
+    /**
+     * Migration got halted due to an error or miss-configuration.
+     **/
+    Halted: GenericPalletEvent<Rv, 'StateTrieMigration', 'Halted', { error: PalletStateTrieMigrationError }>;
+
     /**
      * Generic pallet event
      **/

package/kusama-asset-hub/index.d.ts

@@ -23,7 +23,7 @@ export interface VersionedKusamaAssetHubApi<Rv extends RpcVersion> extends Gener
 
 /**
  * @name: KusamaAssetHubApi
- * @specVersion: 1004000
+ * @specVersion: 1004002
  **/
 export interface KusamaAssetHubApi {
   legacy: VersionedKusamaAssetHubApi<RpcLegacy>;

package/kusama-asset-hub/query.d.ts

@@ -79,6 +79,8 @@ import type {
   StagingXcmV4Location,
   PalletNftFractionalizationDetails,
   PalletAssetConversionPoolInfo,
+  PalletStateTrieMigrationMigrationTask,
+  PalletStateTrieMigrationMigrationLimits,
 } from './types';
 
 export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage<Rv> {
@@ -1222,6 +1224,23 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
      **/
     [storage: string]: GenericStorageQuery<Rv>;
   };
+  /**
+   * Pallet `RemoteProxyRelayChain`'s storage queries
+   **/
+  remoteProxyRelayChain: {
+    /**
+     * Stores the last [`Config::MaxStorageRootsToKeep`] block to storage root mappings of the
+     * target chain.
+     *
+     * @param {Callback<Array<[number, H256]>> =} callback
+     **/
+    blockToRoot: GenericStorageQuery<Rv, () => Array<[number, H256]>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
   /**
    * Pallet `Assets`'s storage queries
    **/
@@ -1743,6 +1762,43 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
      **/
     nextPoolAssetId: GenericStorageQuery<Rv, () => number | undefined>;
 
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s storage queries
+   **/
+  stateTrieMigration: {
+    /**
+     * Migration progress.
+     *
+     * This stores the snapshot of the last migrated keys. It can be set into motion and move
+     * forward by any of the means provided by this pallet.
+     *
+     * @param {Callback<PalletStateTrieMigrationMigrationTask> =} callback
+     **/
+    migrationProcess: GenericStorageQuery<Rv, () => PalletStateTrieMigrationMigrationTask>;
+
+    /**
+     * The limits that are imposed on automatic migrations.
+     *
+     * If set to None, then no automatic migration happens.
+     *
+     * @param {Callback<PalletStateTrieMigrationMigrationLimits | undefined> =} callback
+     **/
+    autoLimits: GenericStorageQuery<Rv, () => PalletStateTrieMigrationMigrationLimits | undefined>;
+
+    /**
+     * The maximum limits that the signed migration could use.
+     *
+     * If not set, no signed submission is allowed.
+     *
+     * @param {Callback<PalletStateTrieMigrationMigrationLimits | undefined> =} callback
+     **/
+    signedMigrationMaxLimits: GenericStorageQuery<Rv, () => PalletStateTrieMigrationMigrationLimits | undefined>;
+
     /**
      * Generic pallet storage query
      **/

package/kusama-asset-hub/tx.d.ts

@@ -31,6 +31,7 @@ import type {
   AssetHubKusamaRuntimeOriginCaller,
   PalletMultisigTimepoint,
   AssetHubKusamaRuntimeProxyType,
+  PalletRemoteProxyRemoteProxyProof,
   PalletUniquesDestroyWitness,
   PalletNftsCollectionConfig,
   PalletNftsDestroyWitness,
@@ -44,6 +45,9 @@ import type {
   PalletNftsPriceWithDirection,
   PalletNftsPreSignedMint,
   PalletNftsPreSignedAttributes,
+  PalletStateTrieMigrationMigrationLimits,
+  PalletStateTrieMigrationMigrationTask,
+  PalletStateTrieMigrationProgress,
 } from './types';
 
 export type ChainSubmittableExtrinsic<
@@ -2798,6 +2802,143 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      **/
     [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
   };
+  /**
+   * Pallet `RemoteProxyRelayChain`'s transaction calls
+   **/
+  remoteProxyRelayChain: {
+    /**
+     * Dispatch the given `call` from an account that the sender is authorised on a remote
+     * chain.
+     *
+     * The dispatch origin for this call must be _Signed_.
+     *
+     * Parameters:
+     * - `real`: The account that the proxy will make a call on behalf of.
+     * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+     * - `call`: The call to be made by the `real` account.
+     * - `proof`: The proof from the remote chain about the existence of the proxy.
+     *
+     * @param {MultiAddressLike} real
+     * @param {AssetHubKusamaRuntimeProxyType | undefined} forceProxyType
+     * @param {AssetHubKusamaRuntimeRuntimeCallLike} call
+     * @param {PalletRemoteProxyRemoteProxyProof} proof
+     **/
+    remoteProxy: GenericTxCall<
+      Rv,
+      (
+        real: MultiAddressLike,
+        forceProxyType: AssetHubKusamaRuntimeProxyType | undefined,
+        call: AssetHubKusamaRuntimeRuntimeCallLike,
+        proof: PalletRemoteProxyRemoteProxyProof,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RemoteProxyRelayChain';
+          palletCall: {
+            name: 'RemoteProxy';
+            params: {
+              real: MultiAddressLike;
+              forceProxyType: AssetHubKusamaRuntimeProxyType | undefined;
+              call: AssetHubKusamaRuntimeRuntimeCallLike;
+              proof: PalletRemoteProxyRemoteProxyProof;
+            };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Register a given remote proxy proof in the current [`dispatch_context`].
+     *
+     * The registered remote proof can then be used later in the same context to execute a
+     * remote proxy call. This is for example useful when having a multisig operation. The
+     * multisig call can use [`Self::remote_proxy_with_registered_proof`] to get an approval by
+     * the members of the multisig. The final execution of the multisig call should be at least
+     * a batch of `register_remote_proxy_proof` and the multisig call that uses
+     * `remote_proxy_with_registered_proof`. This way the final approver can use a recent proof
+     * to prove the existence of the remote proxy. Otherwise it would require the multisig
+     * members to approve the call in [`Config::MaxStorageRootsToKeep`] amount of time.
+     *
+     * It is supported to register multiple proofs, but the proofs need to be consumed in the
+     * reverse order as they were registered. Basically this means last in, first out.
+     *
+     * The [`dispatch_context`] spans the entire lifetime of a transaction and every call in
+     * the transaction gets access to the same context.
+     *
+     * # Example
+     *
+     * ```ignore
+     * batch([
+     * register_remote_proxy_proof,
+     * as_multisig(remote_proxy_with_registered_proof(transfer))
+     * ])
+     * ```
+     *
+     * As `proofs` can not be verified indefinitely (the time the storage roots are stored is
+     * limited) this function provides the possibility to provide a "fresh proof" at time of
+     * dispatch. As in the example above, this could be useful for multisig operation that
+     * depend on multiple members to approve a certain action, which can take multiple days.
+     *
+     * @param {PalletRemoteProxyRemoteProxyProof} proof
+     **/
+    registerRemoteProxyProof: GenericTxCall<
+      Rv,
+      (proof: PalletRemoteProxyRemoteProxyProof) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RemoteProxyRelayChain';
+          palletCall: {
+            name: 'RegisterRemoteProxyProof';
+            params: { proof: PalletRemoteProxyRemoteProxyProof };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Dispatch the given `call` from an account that the sender is authorised on a remote
+     * chain.
+     *
+     * The dispatch origin for this call must be _Signed_. The difference to
+     * [`Self::remote_proxy`] is that the proof nees to registered before using
+     * [`Self::register_remote_proxy_proof`] (see for more information).
+     *
+     * Parameters:
+     * - `real`: The account that the proxy will make a call on behalf of.
+     * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+     * - `call`: The call to be made by the `real` account.
+     *
+     * @param {MultiAddressLike} real
+     * @param {AssetHubKusamaRuntimeProxyType | undefined} forceProxyType
+     * @param {AssetHubKusamaRuntimeRuntimeCallLike} call
+     **/
+    remoteProxyWithRegisteredProof: GenericTxCall<
+      Rv,
+      (
+        real: MultiAddressLike,
+        forceProxyType: AssetHubKusamaRuntimeProxyType | undefined,
+        call: AssetHubKusamaRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'RemoteProxyRelayChain';
+          palletCall: {
+            name: 'RemoteProxyWithRegisteredProof';
+            params: {
+              real: MultiAddressLike;
+              forceProxyType: AssetHubKusamaRuntimeProxyType | undefined;
+              call: AssetHubKusamaRuntimeRuntimeCallLike;
+            };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
   /**
    * Pallet `Assets`'s transaction calls
    **/
@@ -9217,6 +9358,191 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s transaction calls
+   **/
+  stateTrieMigration: {
+    /**
+     * Control the automatic migration.
+     *
+     * The dispatch origin of this call must be [`Config::ControlOrigin`].
+     *
+     * @param {PalletStateTrieMigrationMigrationLimits | undefined} maybeConfig
+     **/
+    controlAutoMigration: GenericTxCall<
+      Rv,
+      (maybeConfig: PalletStateTrieMigrationMigrationLimits | undefined) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'ControlAutoMigration';
+            params: { maybeConfig: PalletStateTrieMigrationMigrationLimits | undefined };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Continue the migration for the given `limits`.
+     *
+     * The dispatch origin of this call can be any signed account.
+     *
+     * This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,
+     * Upon successful execution, the transaction fee is returned.
+     *
+     * The (potentially over-estimated) of the byte length of all the data read must be
+     * provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing
+     * that executing the current `MigrationTask` with the given `limits` will not exceed
+     * `real_size_upper` bytes of read data.
+     *
+     * The `witness_task` is merely a helper to prevent the caller from being slashed or
+     * generally trigger a migration that they do not intend. This parameter is just a message
+     * from caller, saying that they believed `witness_task` was the last state of the
+     * migration, and they only wish for their transaction to do anything, if this assumption
+     * holds. In case `witness_task` does not match, the transaction fails.
+     *
+     * Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the
+     * recommended way of doing this is to pass a `limit` that only bounds `count`, as the
+     * `size` limit can always be overwritten.
+     *
+     * @param {PalletStateTrieMigrationMigrationLimits} limits
+     * @param {number} realSizeUpper
+     * @param {PalletStateTrieMigrationMigrationTask} witnessTask
+     **/
+    continueMigrate: GenericTxCall<
+      Rv,
+      (
+        limits: PalletStateTrieMigrationMigrationLimits,
+        realSizeUpper: number,
+        witnessTask: PalletStateTrieMigrationMigrationTask,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'ContinueMigrate';
+            params: {
+              limits: PalletStateTrieMigrationMigrationLimits;
+              realSizeUpper: number;
+              witnessTask: PalletStateTrieMigrationMigrationTask;
+            };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Migrate the list of top keys by iterating each of them one by one.
+     *
+     * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+     * should only be used in case any keys are leftover due to a bug.
+     *
+     * @param {Array<BytesLike>} keys
+     * @param {number} witnessSize
+     **/
+    migrateCustomTop: GenericTxCall<
+      Rv,
+      (
+        keys: Array<BytesLike>,
+        witnessSize: number,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'MigrateCustomTop';
+            params: { keys: Array<BytesLike>; witnessSize: number };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Migrate the list of child keys by iterating each of them one by one.
+     *
+     * All of the given child keys must be present under one `child_root`.
+     *
+     * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+     * should only be used in case any keys are leftover due to a bug.
+     *
+     * @param {BytesLike} root
+     * @param {Array<BytesLike>} childKeys
+     * @param {number} totalSize
+     **/
+    migrateCustomChild: GenericTxCall<
+      Rv,
+      (
+        root: BytesLike,
+        childKeys: Array<BytesLike>,
+        totalSize: number,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'MigrateCustomChild';
+            params: { root: BytesLike; childKeys: Array<BytesLike>; totalSize: number };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Set the maximum limit of the signed migration.
+     *
+     * @param {PalletStateTrieMigrationMigrationLimits} limits
+     **/
+    setSignedMaxLimits: GenericTxCall<
+      Rv,
+      (limits: PalletStateTrieMigrationMigrationLimits) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'SetSignedMaxLimits';
+            params: { limits: PalletStateTrieMigrationMigrationLimits };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Forcefully set the progress the running migration.
+     *
+     * This is only useful in one case: the next key to migrate is too big to be migrated with
+     * a signed account, in a parachain context, and we simply want to skip it. A reasonable
+     * example of this would be `:code:`, which is both very expensive to migrate, and commonly
+     * used, so probably it is already migrated.
+     *
+     * In case you mess things up, you can also, in principle, use this to reset the migration
+     * process.
+     *
+     * @param {PalletStateTrieMigrationProgress} progressTop
+     * @param {PalletStateTrieMigrationProgress} progressChild
+     **/
+    forceSetProgress: GenericTxCall<
+      Rv,
+      (
+        progressTop: PalletStateTrieMigrationProgress,
+        progressChild: PalletStateTrieMigrationProgress,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'ForceSetProgress';
+            params: { progressTop: PalletStateTrieMigrationProgress; progressChild: PalletStateTrieMigrationProgress };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/

package/kusama-asset-hub/types.d.ts

@@ -71,7 +71,8 @@ export type AssetHubKusamaRuntimeRuntimeEvent =
   | { pallet: 'ForeignAssets'; palletEvent: PalletAssetsEvent002 }
   | { pallet: 'NftFractionalization'; palletEvent: PalletNftFractionalizationEvent }
   | { pallet: 'PoolAssets'; palletEvent: PalletAssetsEvent }
-  | { pallet: 'AssetConversion'; palletEvent: PalletAssetConversionEvent };
+  | { pallet: 'AssetConversion'; palletEvent: PalletAssetConversionEvent }
+  | { pallet: 'StateTrieMigration'; palletEvent: PalletStateTrieMigrationEvent };
 
 /**
  * Event for the System pallet.
@@ -2096,6 +2097,65 @@ export type PalletAssetConversionEvent =
       };
     };
 
+/**
+ * Inner events of this pallet.
+ **/
+export type PalletStateTrieMigrationEvent =
+  /**
+   * Given number of `(top, child)` keys were migrated respectively, with the given
+   * `compute`.
+   **/
+  | { name: 'Migrated'; data: { top: number; child: number; compute: PalletStateTrieMigrationMigrationCompute } }
+  /**
+   * Some account got slashed by the given amount.
+   **/
+  | { name: 'Slashed'; data: { who: AccountId32; amount: bigint } }
+  /**
+   * The auto migration task finished.
+   **/
+  | { name: 'AutoMigrationFinished' }
+  /**
+   * Migration got halted due to an error or miss-configuration.
+   **/
+  | { name: 'Halted'; data: { error: PalletStateTrieMigrationError } };
+
+export type PalletStateTrieMigrationMigrationCompute = 'Signed' | 'Auto';
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletStateTrieMigrationError =
+  /**
+   * Max signed limits not respected.
+   **/
+  | 'MaxSignedLimits'
+  /**
+   * A key was longer than the configured maximum.
+   *
+   * This means that the migration halted at the current [`Progress`] and
+   * can be resumed with a larger [`crate::Config::MaxKeyLen`] value.
+   * Retrying with the same [`crate::Config::MaxKeyLen`] value will not work.
+   * The value should only be increased to avoid a storage migration for the currently
+   * stored [`crate::Progress::LastKey`].
+   **/
+  | 'KeyTooLong'
+  /**
+   * submitter does not have enough funds.
+   **/
+  | 'NotEnoughFunds'
+  /**
+   * Bad witness data provided.
+   **/
+  | 'BadWitness'
+  /**
+   * Signed migration is not allowed because the maximum limit is not set yet.
+   **/
+  | 'SignedMigrationNotAllowed'
+  /**
+   * Bad child root provided.
+   **/
+  | 'BadChildRoot';
+
 export type FrameSystemLastRuntimeUpgradeInfo = { specVersion: number; specName: string };
 
 export type FrameSystemCodeUpgradeAuthorization = { codeHash: H256; checkVersion: boolean };
@@ -4875,13 +4935,15 @@ export type AssetHubKusamaRuntimeRuntimeCall =
   | { pallet: 'Utility'; palletCall: PalletUtilityCall }
   | { pallet: 'Multisig'; palletCall: PalletMultisigCall }
   | { pallet: 'Proxy'; palletCall: PalletProxyCall }
+  | { pallet: 'RemoteProxyRelayChain'; palletCall: PalletRemoteProxyCall }
   | { pallet: 'Assets'; palletCall: PalletAssetsCall }
   | { pallet: 'Uniques'; palletCall: PalletUniquesCall }
   | { pallet: 'Nfts'; palletCall: PalletNftsCall }
   | { pallet: 'ForeignAssets'; palletCall: PalletAssetsCall002 }
   | { pallet: 'NftFractionalization'; palletCall: PalletNftFractionalizationCall }
   | { pallet: 'PoolAssets'; palletCall: PalletAssetsCall003 }
-  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCall };
+  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCall }
+  | { pallet: 'StateTrieMigration'; palletCall: PalletStateTrieMigrationCall };
 
 export type AssetHubKusamaRuntimeRuntimeCallLike =
   | { pallet: 'System'; palletCall: FrameSystemCallLike }
@@ -4900,13 +4962,15 @@ export type AssetHubKusamaRuntimeRuntimeCallLike =
   | { pallet: 'Utility'; palletCall: PalletUtilityCallLike }
   | { pallet: 'Multisig'; palletCall: PalletMultisigCallLike }
   | { pallet: 'Proxy'; palletCall: PalletProxyCallLike }
+  | { pallet: 'RemoteProxyRelayChain'; palletCall: PalletRemoteProxyCallLike }
   | { pallet: 'Assets'; palletCall: PalletAssetsCallLike }
   | { pallet: 'Uniques'; palletCall: PalletUniquesCallLike }
   | { pallet: 'Nfts'; palletCall: PalletNftsCallLike }
   | { pallet: 'ForeignAssets'; palletCall: PalletAssetsCallLike002 }
   | { pallet: 'NftFractionalization'; palletCall: PalletNftFractionalizationCallLike }
   | { pallet: 'PoolAssets'; palletCall: PalletAssetsCallLike003 }
-  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCallLike };
+  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCallLike }
+  | { pallet: 'StateTrieMigration'; palletCall: PalletStateTrieMigrationCallLike };
 
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
@@ -5547,6 +5611,165 @@ export type PalletProxyCallLike =
       };
     };
 
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletRemoteProxyCall =
+  /**
+   * Dispatch the given `call` from an account that the sender is authorised on a remote
+   * chain.
+   *
+   * The dispatch origin for this call must be _Signed_.
+   *
+   * Parameters:
+   * - `real`: The account that the proxy will make a call on behalf of.
+   * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+   * - `call`: The call to be made by the `real` account.
+   * - `proof`: The proof from the remote chain about the existence of the proxy.
+   **/
+  | {
+      name: 'RemoteProxy';
+      params: {
+        real: MultiAddress;
+        forceProxyType?: AssetHubKusamaRuntimeProxyType | undefined;
+        call: AssetHubKusamaRuntimeRuntimeCall;
+        proof: PalletRemoteProxyRemoteProxyProof;
+      };
+    }
+  /**
+   * Register a given remote proxy proof in the current [`dispatch_context`].
+   *
+   * The registered remote proof can then be used later in the same context to execute a
+   * remote proxy call. This is for example useful when having a multisig operation. The
+   * multisig call can use [`Self::remote_proxy_with_registered_proof`] to get an approval by
+   * the members of the multisig. The final execution of the multisig call should be at least
+   * a batch of `register_remote_proxy_proof` and the multisig call that uses
+   * `remote_proxy_with_registered_proof`. This way the final approver can use a recent proof
+   * to prove the existence of the remote proxy. Otherwise it would require the multisig
+   * members to approve the call in [`Config::MaxStorageRootsToKeep`] amount of time.
+   *
+   * It is supported to register multiple proofs, but the proofs need to be consumed in the
+   * reverse order as they were registered. Basically this means last in, first out.
+   *
+   * The [`dispatch_context`] spans the entire lifetime of a transaction and every call in
+   * the transaction gets access to the same context.
+   *
+   * # Example
+   *
+   * ```ignore
+   * batch([
+   * register_remote_proxy_proof,
+   * as_multisig(remote_proxy_with_registered_proof(transfer))
+   * ])
+   * ```
+   *
+   * As `proofs` can not be verified indefinitely (the time the storage roots are stored is
+   * limited) this function provides the possibility to provide a "fresh proof" at time of
+   * dispatch. As in the example above, this could be useful for multisig operation that
+   * depend on multiple members to approve a certain action, which can take multiple days.
+   **/
+  | { name: 'RegisterRemoteProxyProof'; params: { proof: PalletRemoteProxyRemoteProxyProof } }
+  /**
+   * Dispatch the given `call` from an account that the sender is authorised on a remote
+   * chain.
+   *
+   * The dispatch origin for this call must be _Signed_. The difference to
+   * [`Self::remote_proxy`] is that the proof nees to registered before using
+   * [`Self::register_remote_proxy_proof`] (see for more information).
+   *
+   * Parameters:
+   * - `real`: The account that the proxy will make a call on behalf of.
+   * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+   * - `call`: The call to be made by the `real` account.
+   **/
+  | {
+      name: 'RemoteProxyWithRegisteredProof';
+      params: {
+        real: MultiAddress;
+        forceProxyType?: AssetHubKusamaRuntimeProxyType | undefined;
+        call: AssetHubKusamaRuntimeRuntimeCall;
+      };
+    };
+
+export type PalletRemoteProxyCallLike =
+  /**
+   * Dispatch the given `call` from an account that the sender is authorised on a remote
+   * chain.
+   *
+   * The dispatch origin for this call must be _Signed_.
+   *
+   * Parameters:
+   * - `real`: The account that the proxy will make a call on behalf of.
+   * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+   * - `call`: The call to be made by the `real` account.
+   * - `proof`: The proof from the remote chain about the existence of the proxy.
+   **/
+  | {
+      name: 'RemoteProxy';
+      params: {
+        real: MultiAddressLike;
+        forceProxyType?: AssetHubKusamaRuntimeProxyType | undefined;
+        call: AssetHubKusamaRuntimeRuntimeCallLike;
+        proof: PalletRemoteProxyRemoteProxyProof;
+      };
+    }
+  /**
+   * Register a given remote proxy proof in the current [`dispatch_context`].
+   *
+   * The registered remote proof can then be used later in the same context to execute a
+   * remote proxy call. This is for example useful when having a multisig operation. The
+   * multisig call can use [`Self::remote_proxy_with_registered_proof`] to get an approval by
+   * the members of the multisig. The final execution of the multisig call should be at least
+   * a batch of `register_remote_proxy_proof` and the multisig call that uses
+   * `remote_proxy_with_registered_proof`. This way the final approver can use a recent proof
+   * to prove the existence of the remote proxy. Otherwise it would require the multisig
+   * members to approve the call in [`Config::MaxStorageRootsToKeep`] amount of time.
+   *
+   * It is supported to register multiple proofs, but the proofs need to be consumed in the
+   * reverse order as they were registered. Basically this means last in, first out.
+   *
+   * The [`dispatch_context`] spans the entire lifetime of a transaction and every call in
+   * the transaction gets access to the same context.
+   *
+   * # Example
+   *
+   * ```ignore
+   * batch([
+   * register_remote_proxy_proof,
+   * as_multisig(remote_proxy_with_registered_proof(transfer))
+   * ])
+   * ```
+   *
+   * As `proofs` can not be verified indefinitely (the time the storage roots are stored is
+   * limited) this function provides the possibility to provide a "fresh proof" at time of
+   * dispatch. As in the example above, this could be useful for multisig operation that
+   * depend on multiple members to approve a certain action, which can take multiple days.
+   **/
+  | { name: 'RegisterRemoteProxyProof'; params: { proof: PalletRemoteProxyRemoteProxyProof } }
+  /**
+   * Dispatch the given `call` from an account that the sender is authorised on a remote
+   * chain.
+   *
+   * The dispatch origin for this call must be _Signed_. The difference to
+   * [`Self::remote_proxy`] is that the proof nees to registered before using
+   * [`Self::register_remote_proxy_proof`] (see for more information).
+   *
+   * Parameters:
+   * - `real`: The account that the proxy will make a call on behalf of.
+   * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+   * - `call`: The call to be made by the `real` account.
+   **/
+  | {
+      name: 'RemoteProxyWithRegisteredProof';
+      params: {
+        real: MultiAddressLike;
+        forceProxyType?: AssetHubKusamaRuntimeProxyType | undefined;
+        call: AssetHubKusamaRuntimeRuntimeCallLike;
+      };
+    };
+
+export type PalletRemoteProxyRemoteProxyProof = { type: 'RelayChain'; value: { proof: Array<Bytes>; block: number } };
+
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
  **/
@@ -11646,6 +11869,172 @@ export type PalletAssetConversionCallLike =
    **/
   | { name: 'Touch'; params: { asset1: StagingXcmV4Location; asset2: StagingXcmV4Location } };
 
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletStateTrieMigrationCall =
+  /**
+   * Control the automatic migration.
+   *
+   * The dispatch origin of this call must be [`Config::ControlOrigin`].
+   **/
+  | { name: 'ControlAutoMigration'; params: { maybeConfig?: PalletStateTrieMigrationMigrationLimits | undefined } }
+  /**
+   * Continue the migration for the given `limits`.
+   *
+   * The dispatch origin of this call can be any signed account.
+   *
+   * This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,
+   * Upon successful execution, the transaction fee is returned.
+   *
+   * The (potentially over-estimated) of the byte length of all the data read must be
+   * provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing
+   * that executing the current `MigrationTask` with the given `limits` will not exceed
+   * `real_size_upper` bytes of read data.
+   *
+   * The `witness_task` is merely a helper to prevent the caller from being slashed or
+   * generally trigger a migration that they do not intend. This parameter is just a message
+   * from caller, saying that they believed `witness_task` was the last state of the
+   * migration, and they only wish for their transaction to do anything, if this assumption
+   * holds. In case `witness_task` does not match, the transaction fails.
+   *
+   * Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the
+   * recommended way of doing this is to pass a `limit` that only bounds `count`, as the
+   * `size` limit can always be overwritten.
+   **/
+  | {
+      name: 'ContinueMigrate';
+      params: {
+        limits: PalletStateTrieMigrationMigrationLimits;
+        realSizeUpper: number;
+        witnessTask: PalletStateTrieMigrationMigrationTask;
+      };
+    }
+  /**
+   * Migrate the list of top keys by iterating each of them one by one.
+   *
+   * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+   * should only be used in case any keys are leftover due to a bug.
+   **/
+  | { name: 'MigrateCustomTop'; params: { keys: Array<Bytes>; witnessSize: number } }
+  /**
+   * Migrate the list of child keys by iterating each of them one by one.
+   *
+   * All of the given child keys must be present under one `child_root`.
+   *
+   * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+   * should only be used in case any keys are leftover due to a bug.
+   **/
+  | { name: 'MigrateCustomChild'; params: { root: Bytes; childKeys: Array<Bytes>; totalSize: number } }
+  /**
+   * Set the maximum limit of the signed migration.
+   **/
+  | { name: 'SetSignedMaxLimits'; params: { limits: PalletStateTrieMigrationMigrationLimits } }
+  /**
+   * Forcefully set the progress the running migration.
+   *
+   * This is only useful in one case: the next key to migrate is too big to be migrated with
+   * a signed account, in a parachain context, and we simply want to skip it. A reasonable
+   * example of this would be `:code:`, which is both very expensive to migrate, and commonly
+   * used, so probably it is already migrated.
+   *
+   * In case you mess things up, you can also, in principle, use this to reset the migration
+   * process.
+   **/
+  | {
+      name: 'ForceSetProgress';
+      params: { progressTop: PalletStateTrieMigrationProgress; progressChild: PalletStateTrieMigrationProgress };
+    };
+
+export type PalletStateTrieMigrationCallLike =
+  /**
+   * Control the automatic migration.
+   *
+   * The dispatch origin of this call must be [`Config::ControlOrigin`].
+   **/
+  | { name: 'ControlAutoMigration'; params: { maybeConfig?: PalletStateTrieMigrationMigrationLimits | undefined } }
+  /**
+   * Continue the migration for the given `limits`.
+   *
+   * The dispatch origin of this call can be any signed account.
+   *
+   * This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,
+   * Upon successful execution, the transaction fee is returned.
+   *
+   * The (potentially over-estimated) of the byte length of all the data read must be
+   * provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing
+   * that executing the current `MigrationTask` with the given `limits` will not exceed
+   * `real_size_upper` bytes of read data.
+   *
+   * The `witness_task` is merely a helper to prevent the caller from being slashed or
+   * generally trigger a migration that they do not intend. This parameter is just a message
+   * from caller, saying that they believed `witness_task` was the last state of the
+   * migration, and they only wish for their transaction to do anything, if this assumption
+   * holds. In case `witness_task` does not match, the transaction fails.
+   *
+   * Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the
+   * recommended way of doing this is to pass a `limit` that only bounds `count`, as the
+   * `size` limit can always be overwritten.
+   **/
+  | {
+      name: 'ContinueMigrate';
+      params: {
+        limits: PalletStateTrieMigrationMigrationLimits;
+        realSizeUpper: number;
+        witnessTask: PalletStateTrieMigrationMigrationTask;
+      };
+    }
+  /**
+   * Migrate the list of top keys by iterating each of them one by one.
+   *
+   * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+   * should only be used in case any keys are leftover due to a bug.
+   **/
+  | { name: 'MigrateCustomTop'; params: { keys: Array<BytesLike>; witnessSize: number } }
+  /**
+   * Migrate the list of child keys by iterating each of them one by one.
+   *
+   * All of the given child keys must be present under one `child_root`.
+   *
+   * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+   * should only be used in case any keys are leftover due to a bug.
+   **/
+  | { name: 'MigrateCustomChild'; params: { root: BytesLike; childKeys: Array<BytesLike>; totalSize: number } }
+  /**
+   * Set the maximum limit of the signed migration.
+   **/
+  | { name: 'SetSignedMaxLimits'; params: { limits: PalletStateTrieMigrationMigrationLimits } }
+  /**
+   * Forcefully set the progress the running migration.
+   *
+   * This is only useful in one case: the next key to migrate is too big to be migrated with
+   * a signed account, in a parachain context, and we simply want to skip it. A reasonable
+   * example of this would be `:code:`, which is both very expensive to migrate, and commonly
+   * used, so probably it is already migrated.
+   *
+   * In case you mess things up, you can also, in principle, use this to reset the migration
+   * process.
+   **/
+  | {
+      name: 'ForceSetProgress';
+      params: { progressTop: PalletStateTrieMigrationProgress; progressChild: PalletStateTrieMigrationProgress };
+    };
+
+export type PalletStateTrieMigrationMigrationLimits = { size: number; item: number };
+
+export type PalletStateTrieMigrationMigrationTask = {
+  progressTop: PalletStateTrieMigrationProgress;
+  progressChild: PalletStateTrieMigrationProgress;
+  size: number;
+  topItems: number;
+  childItems: number;
+};
+
+export type PalletStateTrieMigrationProgress =
+  | { type: 'ToStart' }
+  | { type: 'LastKey'; value: Bytes }
+  | { type: 'Complete' };
+
 export type AssetHubKusamaRuntimeOriginCaller =
   | { type: 'System'; value: FrameSupportDispatchRawOrigin }
   | { type: 'PolkadotXcm'; value: PalletXcmOrigin }
@@ -11789,6 +12178,39 @@ export type PalletProxyError =
    **/
   | 'NoSelfProxy';
 
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletRemoteProxyError =
+  /**
+   * The local account id could not converted to the remote account id.
+   **/
+  | 'CouldNotConvertLocalToRemoteAccountId'
+  /**
+   * The anchor block of the remote proof is unknown.
+   **/
+  | 'UnknownProofAnchorBlock'
+  /**
+   * The proxy definition could not be found in the proof.
+   **/
+  | 'InvalidProof'
+  /**
+   * Failed to decode the remote proxy definition from the proof.
+   **/
+  | 'ProxyDefinitionDecodingFailed'
+  /**
+   * Announcement, if made at all, was made too recently.
+   **/
+  | 'Unannounced'
+  /**
+   * Could not find any matching proxy definition in the proof.
+   **/
+  | 'DidNotFindMatchingProxyDefinition'
+  /**
+   * Proxy proof not registered.
+   **/
+  | 'ProxyProofNotRegistered';
+
 export type PalletAssetsAssetDetails = {
   owner: AccountId32;
   issuer: AccountId32;
@@ -12525,10 +12947,12 @@ export type AssetHubKusamaRuntimeRuntimeError =
   | { pallet: 'Utility'; palletError: PalletUtilityError }
   | { pallet: 'Multisig'; palletError: PalletMultisigError }
   | { pallet: 'Proxy'; palletError: PalletProxyError }
+  | { pallet: 'RemoteProxyRelayChain'; palletError: PalletRemoteProxyError }
   | { pallet: 'Assets'; palletError: PalletAssetsError }
   | { pallet: 'Uniques'; palletError: PalletUniquesError }
   | { pallet: 'Nfts'; palletError: PalletNftsError }
   | { pallet: 'ForeignAssets'; palletError: PalletAssetsError }
   | { pallet: 'NftFractionalization'; palletError: PalletNftFractionalizationError }
   | { pallet: 'PoolAssets'; palletError: PalletAssetsError }
-  | { pallet: 'AssetConversion'; palletError: PalletAssetConversionError };
+  | { pallet: 'AssetConversion'; palletError: PalletAssetConversionError }
+  | { pallet: 'StateTrieMigration'; palletError: PalletStateTrieMigrationError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/chaintypes",
-  "version": "0.69.0",
+  "version": "0.70.0",
   "description": "Types for substrate-based chains",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "main": "",
@@ -19,7 +19,7 @@
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "825e0f549216783fa7989387cbb7023e1247e5f9",
+  "gitHead": "1fe9aea0f268277d06948e19152baf6b86b3e43e",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/westend-asset-hub/errors.d.ts

@@ -1828,6 +1828,11 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     UnsupportedPrecompileAddress: GenericPalletError<Rv>;
 
+    /**
+     * Precompile Error
+     **/
+    PrecompileFailure: GenericPalletError<Rv>;
+
     /**
      * Generic pallet error
      **/

package/westend-asset-hub/index.d.ts

@@ -23,7 +23,7 @@ export interface VersionedWestendAssetHubApi<Rv extends RpcVersion> extends Gene
 
 /**
  * @name: WestendAssetHubApi
- * @specVersion: 1018000
+ * @specVersion: 1018001
  **/
 export interface WestendAssetHubApi {
   legacy: VersionedWestendAssetHubApi<RpcLegacy>;

package/westend-asset-hub/types.d.ts

@@ -13796,7 +13796,11 @@ export type PalletReviveError =
   /**
    * Unsupported precompile address
    **/
-  | 'UnsupportedPrecompileAddress';
+  | 'UnsupportedPrecompileAddress'
+  /**
+   * Precompile Error
+   **/
+  | 'PrecompileFailure';
 
 export type PalletAssetRewardsPoolStakerInfo = { amount: bigint; rewards: bigint; rewardPerTokenPaid: bigint };
 
@@ -14072,7 +14076,7 @@ export type PalletReviveEvmApiRpcTypesGenGenericTransaction = {
   from?: H160 | undefined;
   gas?: U256 | undefined;
   gasPrice?: U256 | undefined;
-  input?: PalletReviveEvmApiByteBytes | undefined;
+  input: PalletReviveEvmApiRpcTypesGenInputOrData;
   maxFeePerBlobGas?: U256 | undefined;
   maxFeePerGas?: U256 | undefined;
   maxPriorityFeePerGas?: U256 | undefined;
@@ -14086,6 +14090,11 @@ export type PalletReviveEvmApiRpcTypesGenAccessListEntry = { address: H160; stor
 
 export type PalletReviveEvmApiByteBytes = Bytes;
 
+export type PalletReviveEvmApiRpcTypesGenInputOrData = {
+  input?: PalletReviveEvmApiByteBytes | undefined;
+  data?: PalletReviveEvmApiByteBytes | undefined;
+};
+
 export type PalletReviveEvmApiByte = number;
 
 export type PalletRevivePrimitivesEthTransactInfo = {