@dedot/chaintypes 0.68.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
      **/