@dedot/chaintypes 0.31.0 → 0.33.0

package/moonbeam/consts.d.ts

@@ -980,6 +980,33 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     [name: string]: any;
   };
+  /**
+   * Pallet `EvmForeignAssets`'s constants
+   **/
+  evmForeignAssets: {
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
+  /**
+   * Pallet `XcmWeightTrader`'s constants
+   **/
+  xcmWeightTrader: {
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
+  /**
+   * Pallet `EmergencyParaXcm`'s constants
+   **/
+  emergencyParaXcm: {
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
   /**
    * Pallet `RelayStorageRoots`'s constants
    **/

package/moonbeam/errors.d.ts

@@ -721,6 +721,16 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     ContractNotCorrupted: GenericPalletError<Rv>;
 
+    /**
+     * The contract already have metadata
+     **/
+    ContractMetadataAlreadySet: GenericPalletError<Rv>;
+
+    /**
+     * Contract not exist
+     **/
+    ContractNotExist: GenericPalletError<Rv>;
+
     /**
      * Generic pallet error
      **/
@@ -1881,6 +1891,83 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     [error: string]: GenericPalletError<Rv>;
   };
+  /**
+   * Pallet `EvmForeignAssets`'s errors
+   **/
+  evmForeignAssets: {
+    AssetAlreadyExists: GenericPalletError<Rv>;
+    AssetAlreadyFrozen: GenericPalletError<Rv>;
+    AssetDoesNotExist: GenericPalletError<Rv>;
+    AssetIdFiltered: GenericPalletError<Rv>;
+    AssetNotFrozen: GenericPalletError<Rv>;
+    CorruptedStorageOrphanLocation: GenericPalletError<Rv>;
+    Erc20ContractCreationFail: GenericPalletError<Rv>;
+    EvmCallPauseFail: GenericPalletError<Rv>;
+    EvmCallUnpauseFail: GenericPalletError<Rv>;
+    EvmInternalError: GenericPalletError<Rv>;
+    InvalidSymbol: GenericPalletError<Rv>;
+    InvalidTokenName: GenericPalletError<Rv>;
+    LocationAlreadyExists: GenericPalletError<Rv>;
+    TooManyForeignAssets: GenericPalletError<Rv>;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
+  /**
+   * Pallet `XcmWeightTrader`'s errors
+   **/
+  xcmWeightTrader: {
+    /**
+     * The given asset was already added
+     **/
+    AssetAlreadyAdded: GenericPalletError<Rv>;
+
+    /**
+     * The given asset was already paused
+     **/
+    AssetAlreadyPaused: GenericPalletError<Rv>;
+
+    /**
+     * The given asset was not found
+     **/
+    AssetNotFound: GenericPalletError<Rv>;
+
+    /**
+     * The given asset is not paused
+     **/
+    AssetNotPaused: GenericPalletError<Rv>;
+
+    /**
+     * XCM location filtered
+     **/
+    XcmLocationFiltered: GenericPalletError<Rv>;
+
+    /**
+     * The relative price cannot be zero
+     **/
+    PriceCannotBeZero: GenericPalletError<Rv>;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
+  /**
+   * Pallet `EmergencyParaXcm`'s errors
+   **/
+  emergencyParaXcm: {
+    /**
+     * The current XCM Mode is not Paused
+     **/
+    NotInPausedMode: GenericPalletError<Rv>;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
   /**
    * Pallet `PrecompileBenchmarks`'s errors
    **/

package/moonbeam/events.d.ts

@@ -2610,12 +2610,7 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
     /**
      * Changed the amount of units we are charging per execution second for a given asset
      **/
-    UnitsPerSecondChanged: GenericPalletEvent<
-      Rv,
-      'AssetManager',
-      'UnitsPerSecondChanged',
-      { assetType: MoonbeamRuntimeXcmConfigAssetType; unitsPerSecond: bigint }
-    >;
+    UnitsPerSecondChanged: GenericPalletEvent<Rv, 'AssetManager', 'UnitsPerSecondChanged', null>;
 
     /**
      * Changed the xcm type mapping for a given asset id
@@ -2927,6 +2922,125 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      **/
     [prop: string]: GenericPalletEvent<Rv>;
   };
+  /**
+   * Pallet `EvmForeignAssets`'s events
+   **/
+  evmForeignAssets: {
+    /**
+     * New asset with the asset manager is registered
+     **/
+    ForeignAssetCreated: GenericPalletEvent<
+      Rv,
+      'EvmForeignAssets',
+      'ForeignAssetCreated',
+      { contractAddress: H160; assetId: bigint; xcmLocation: StagingXcmV4Location }
+    >;
+
+    /**
+     * Changed the xcm type mapping for a given asset id
+     **/
+    ForeignAssetXcmLocationChanged: GenericPalletEvent<
+      Rv,
+      'EvmForeignAssets',
+      'ForeignAssetXcmLocationChanged',
+      { assetId: bigint; newXcmLocation: StagingXcmV4Location }
+    >;
+    ForeignAssetFrozen: GenericPalletEvent<
+      Rv,
+      'EvmForeignAssets',
+      'ForeignAssetFrozen',
+      { assetId: bigint; xcmLocation: StagingXcmV4Location }
+    >;
+    ForeignAssetUnfrozen: GenericPalletEvent<
+      Rv,
+      'EvmForeignAssets',
+      'ForeignAssetUnfrozen',
+      { assetId: bigint; xcmLocation: StagingXcmV4Location }
+    >;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
+  /**
+   * Pallet `XcmWeightTrader`'s events
+   **/
+  xcmWeightTrader: {
+    /**
+     * New supported asset is registered
+     **/
+    SupportedAssetAdded: GenericPalletEvent<
+      Rv,
+      'XcmWeightTrader',
+      'SupportedAssetAdded',
+      { location: StagingXcmV4Location; relativePrice: bigint }
+    >;
+
+    /**
+     * Changed the amount of units we are charging per execution second for a given asset
+     **/
+    SupportedAssetEdited: GenericPalletEvent<
+      Rv,
+      'XcmWeightTrader',
+      'SupportedAssetEdited',
+      { location: StagingXcmV4Location; relativePrice: bigint }
+    >;
+
+    /**
+     * Pause support for a given asset
+     **/
+    PauseAssetSupport: GenericPalletEvent<
+      Rv,
+      'XcmWeightTrader',
+      'PauseAssetSupport',
+      { location: StagingXcmV4Location }
+    >;
+
+    /**
+     * Resume support for a given asset
+     **/
+    ResumeAssetSupport: GenericPalletEvent<
+      Rv,
+      'XcmWeightTrader',
+      'ResumeAssetSupport',
+      { location: StagingXcmV4Location }
+    >;
+
+    /**
+     * Supported asset type for fee payment removed
+     **/
+    SupportedAssetRemoved: GenericPalletEvent<
+      Rv,
+      'XcmWeightTrader',
+      'SupportedAssetRemoved',
+      { location: StagingXcmV4Location }
+    >;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
+  /**
+   * Pallet `EmergencyParaXcm`'s events
+   **/
+  emergencyParaXcm: {
+    /**
+     * The XCM incoming execution was Paused
+     **/
+    EnteredPausedXcmMode: GenericPalletEvent<Rv, 'EmergencyParaXcm', 'EnteredPausedXcmMode', undefined>;
+
+    /**
+     * The XCM incoming execution returned to normal operation
+     **/
+    NormalXcmOperationResumed: GenericPalletEvent<Rv, 'EmergencyParaXcm', 'NormalXcmOperationResumed', undefined>;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
   /**
    * Pallet `Randomness`'s events
    **/

package/moonbeam/index.d.ts

@@ -23,7 +23,7 @@ export interface VersionedMoonbeamApi<Rv extends RpcVersion> extends GenericSubs
 
 /**
  * @name: MoonbeamApi
- * @specVersion: 3102
+ * @specVersion: 3200
  **/
 export interface MoonbeamApi {
   legacy: VersionedMoonbeamApi<RpcLegacy>;

package/moonbeam/query.d.ts

@@ -98,6 +98,8 @@ import type {
   PalletMessageQueueBookState,
   CumulusPrimitivesCoreAggregateMessageOrigin,
   PalletMessageQueuePage,
+  PalletMoonbeamForeignAssetsAssetStatus,
+  PalletEmergencyParaXcmXcmMode,
   PalletRandomnessRequestState,
   PalletRandomnessRandomnessResult,
   PalletRandomnessRequestType,
@@ -2065,27 +2067,6 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
       MoonbeamRuntimeXcmConfigAssetType
     >;
 
-    /**
-     * Stores the units per second for local execution for a AssetType.
-     * This is used to know how to charge for XCM execution in a particular
-     * asset
-     * Not all assets might contain units per second, hence the different storage
-     *
-     * @param {MoonbeamRuntimeXcmConfigAssetType} arg
-     * @param {Callback<bigint | undefined> =} callback
-     **/
-    assetTypeUnitsPerSecond: GenericStorageQuery<
-      Rv,
-      (arg: MoonbeamRuntimeXcmConfigAssetType) => bigint | undefined,
-      MoonbeamRuntimeXcmConfigAssetType
-    >;
-
-    /**
-     *
-     * @param {Callback<Array<MoonbeamRuntimeXcmConfigAssetType>> =} callback
-     **/
-    supportedFeePaymentAssets: GenericStorageQuery<Rv, () => Array<MoonbeamRuntimeXcmConfigAssetType>>;
-
     /**
      * Generic pallet storage query
      **/
@@ -2216,6 +2197,85 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
      **/
     [storage: string]: GenericStorageQuery<Rv>;
   };
+  /**
+   * Pallet `EvmForeignAssets`'s storage queries
+   **/
+  evmForeignAssets: {
+    /**
+     * Mapping from an asset id to a Foreign asset type.
+     * This is mostly used when receiving transaction specifying an asset directly,
+     * like transferring an asset from this chain to another.
+     *
+     * @param {bigint} arg
+     * @param {Callback<StagingXcmV4Location | undefined> =} callback
+     **/
+    assetsById: GenericStorageQuery<Rv, (arg: bigint) => StagingXcmV4Location | undefined, bigint>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForAssetsById: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Reverse mapping of AssetsById. Mapping from a foreign asset to an asset id.
+     * This is mostly used when receiving a multilocation XCM message to retrieve
+     * the corresponding asset in which tokens should me minted.
+     *
+     * @param {StagingXcmV4Location} arg
+     * @param {Callback<[bigint, PalletMoonbeamForeignAssetsAssetStatus] | undefined> =} callback
+     **/
+    assetsByLocation: GenericStorageQuery<
+      Rv,
+      (arg: StagingXcmV4Location) => [bigint, PalletMoonbeamForeignAssetsAssetStatus] | undefined,
+      StagingXcmV4Location
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `XcmWeightTrader`'s storage queries
+   **/
+  xcmWeightTrader: {
+    /**
+     * Stores all supported assets per XCM Location.
+     * The u128 is the asset price relative to native asset with 18 decimals
+     * The boolean specify if the support for this asset is active
+     *
+     * @param {StagingXcmV4Location} arg
+     * @param {Callback<[boolean, bigint] | undefined> =} callback
+     **/
+    supportedAssets: GenericStorageQuery<
+      Rv,
+      (arg: StagingXcmV4Location) => [boolean, bigint] | undefined,
+      StagingXcmV4Location
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `EmergencyParaXcm`'s storage queries
+   **/
+  emergencyParaXcm: {
+    /**
+     * Whether incoming XCM is enabled or paused
+     *
+     * @param {Callback<PalletEmergencyParaXcmXcmMode> =} callback
+     **/
+    mode: GenericStorageQuery<Rv, () => PalletEmergencyParaXcmXcmMode>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
   /**
    * Pallet `RelayStorageRoots`'s storage queries
    **/

package/moonbeam/tx.d.ts

@@ -3240,6 +3240,24 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     *
+     * @param {H160} address
+     **/
+    createContractMetadata: GenericTxCall<
+      Rv,
+      (address: H160) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'MoonbeamLazyMigrations';
+          palletCall: {
+            name: 'CreateContractMetadata';
+            params: { address: H160 };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -7226,36 +7244,6 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
-    /**
-     * Change the amount of units we are charging per execution second
-     * for a given ForeignAssetType
-     *
-     * @param {MoonbeamRuntimeXcmConfigAssetType} assetType
-     * @param {bigint} unitsPerSecond
-     * @param {number} numAssetsWeightHint
-     **/
-    setAssetUnitsPerSecond: GenericTxCall<
-      Rv,
-      (
-        assetType: MoonbeamRuntimeXcmConfigAssetType,
-        unitsPerSecond: bigint,
-        numAssetsWeightHint: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'AssetManager';
-          palletCall: {
-            name: 'SetAssetUnitsPerSecond';
-            params: {
-              assetType: MoonbeamRuntimeXcmConfigAssetType;
-              unitsPerSecond: bigint;
-              numAssetsWeightHint: number;
-            };
-          };
-        }
-      >
-    >;
-
     /**
      * Change the xcm type mapping for a given assetId
      * We also change this if the previous units per second where pointing at the old
@@ -7283,28 +7271,6 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
-    /**
-     *
-     * @param {MoonbeamRuntimeXcmConfigAssetType} assetType
-     * @param {number} numAssetsWeightHint
-     **/
-    removeSupportedAsset: GenericTxCall<
-      Rv,
-      (
-        assetType: MoonbeamRuntimeXcmConfigAssetType,
-        numAssetsWeightHint: number,
-      ) => ChainSubmittableExtrinsic<
-        Rv,
-        {
-          pallet: 'AssetManager';
-          palletCall: {
-            name: 'RemoveSupportedAsset';
-            params: { assetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number };
-          };
-        }
-      >
-    >;
-
     /**
      * Remove a given assetId -> assetType association
      *
@@ -8150,6 +8116,269 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      **/
     [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
   };
+  /**
+   * Pallet `EvmForeignAssets`'s transaction calls
+   **/
+  evmForeignAssets: {
+    /**
+     * Create new asset with the ForeignAssetCreator
+     *
+     * @param {bigint} assetId
+     * @param {StagingXcmV4Location} xcmLocation
+     * @param {number} decimals
+     * @param {BytesLike} symbol
+     * @param {BytesLike} name
+     **/
+    createForeignAsset: GenericTxCall<
+      Rv,
+      (
+        assetId: bigint,
+        xcmLocation: StagingXcmV4Location,
+        decimals: number,
+        symbol: BytesLike,
+        name: BytesLike,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'EvmForeignAssets';
+          palletCall: {
+            name: 'CreateForeignAsset';
+            params: {
+              assetId: bigint;
+              xcmLocation: StagingXcmV4Location;
+              decimals: number;
+              symbol: BytesLike;
+              name: BytesLike;
+            };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Change the xcm type mapping for a given assetId
+     * We also change this if the previous units per second where pointing at the old
+     * assetType
+     *
+     * @param {bigint} assetId
+     * @param {StagingXcmV4Location} newXcmLocation
+     **/
+    changeXcmLocation: GenericTxCall<
+      Rv,
+      (
+        assetId: bigint,
+        newXcmLocation: StagingXcmV4Location,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'EvmForeignAssets';
+          palletCall: {
+            name: 'ChangeXcmLocation';
+            params: { assetId: bigint; newXcmLocation: StagingXcmV4Location };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Freeze a given foreign assetId
+     *
+     * @param {bigint} assetId
+     * @param {boolean} allowXcmDeposit
+     **/
+    freezeForeignAsset: GenericTxCall<
+      Rv,
+      (
+        assetId: bigint,
+        allowXcmDeposit: boolean,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'EvmForeignAssets';
+          palletCall: {
+            name: 'FreezeForeignAsset';
+            params: { assetId: bigint; allowXcmDeposit: boolean };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Unfreeze a given foreign assetId
+     *
+     * @param {bigint} assetId
+     **/
+    unfreezeForeignAsset: GenericTxCall<
+      Rv,
+      (assetId: bigint) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'EvmForeignAssets';
+          palletCall: {
+            name: 'UnfreezeForeignAsset';
+            params: { assetId: bigint };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
+  /**
+   * Pallet `XcmWeightTrader`'s transaction calls
+   **/
+  xcmWeightTrader: {
+    /**
+     *
+     * @param {StagingXcmV4Location} location
+     * @param {bigint} relativePrice
+     **/
+    addAsset: GenericTxCall<
+      Rv,
+      (
+        location: StagingXcmV4Location,
+        relativePrice: bigint,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmWeightTrader';
+          palletCall: {
+            name: 'AddAsset';
+            params: { location: StagingXcmV4Location; relativePrice: bigint };
+          };
+        }
+      >
+    >;
+
+    /**
+     *
+     * @param {StagingXcmV4Location} location
+     * @param {bigint} relativePrice
+     **/
+    editAsset: GenericTxCall<
+      Rv,
+      (
+        location: StagingXcmV4Location,
+        relativePrice: bigint,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmWeightTrader';
+          palletCall: {
+            name: 'EditAsset';
+            params: { location: StagingXcmV4Location; relativePrice: bigint };
+          };
+        }
+      >
+    >;
+
+    /**
+     *
+     * @param {StagingXcmV4Location} location
+     **/
+    pauseAssetSupport: GenericTxCall<
+      Rv,
+      (location: StagingXcmV4Location) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmWeightTrader';
+          palletCall: {
+            name: 'PauseAssetSupport';
+            params: { location: StagingXcmV4Location };
+          };
+        }
+      >
+    >;
+
+    /**
+     *
+     * @param {StagingXcmV4Location} location
+     **/
+    resumeAssetSupport: GenericTxCall<
+      Rv,
+      (location: StagingXcmV4Location) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmWeightTrader';
+          palletCall: {
+            name: 'ResumeAssetSupport';
+            params: { location: StagingXcmV4Location };
+          };
+        }
+      >
+    >;
+
+    /**
+     *
+     * @param {StagingXcmV4Location} location
+     **/
+    removeAsset: GenericTxCall<
+      Rv,
+      (location: StagingXcmV4Location) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'XcmWeightTrader';
+          palletCall: {
+            name: 'RemoveAsset';
+            params: { location: StagingXcmV4Location };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
+  /**
+   * Pallet `EmergencyParaXcm`'s transaction calls
+   **/
+  emergencyParaXcm: {
+    /**
+     * Resume `Normal` mode
+     *
+     **/
+    pausedToNormal: GenericTxCall<
+      Rv,
+      () => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'EmergencyParaXcm';
+          palletCall: {
+            name: 'PausedToNormal';
+          };
+        }
+      >
+    >;
+
+    /**
+     * Authorize a runtime upgrade. Only callable in `Paused` mode
+     *
+     * @param {H256} codeHash
+     **/
+    fastAuthorizeUpgrade: GenericTxCall<
+      Rv,
+      (codeHash: H256) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'EmergencyParaXcm';
+          palletCall: {
+            name: 'FastAuthorizeUpgrade';
+            params: { codeHash: H256 };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
   /**
    * Pallet `Randomness`'s transaction calls
    **/

package/moonbeam/types.d.ts

@@ -87,6 +87,9 @@ export type MoonbeamRuntimeRuntimeEvent =
   | { pallet: 'XcmTransactor'; palletEvent: PalletXcmTransactorEvent }
   | { pallet: 'EthereumXcm'; palletEvent: PalletEthereumXcmEvent }
   | { pallet: 'MessageQueue'; palletEvent: PalletMessageQueueEvent }
+  | { pallet: 'EvmForeignAssets'; palletEvent: PalletMoonbeamForeignAssetsEvent }
+  | { pallet: 'XcmWeightTrader'; palletEvent: PalletXcmWeightTraderEvent }
+  | { pallet: 'EmergencyParaXcm'; palletEvent: PalletEmergencyParaXcmEvent }
   | { pallet: 'Randomness'; palletEvent: PalletRandomnessEvent };
 
 /**
@@ -1305,6 +1308,9 @@ export type MoonbeamRuntimeRuntimeCall =
   | { pallet: 'XcmTransactor'; palletCall: PalletXcmTransactorCall }
   | { pallet: 'EthereumXcm'; palletCall: PalletEthereumXcmCall }
   | { pallet: 'MessageQueue'; palletCall: PalletMessageQueueCall }
+  | { pallet: 'EvmForeignAssets'; palletCall: PalletMoonbeamForeignAssetsCall }
+  | { pallet: 'XcmWeightTrader'; palletCall: PalletXcmWeightTraderCall }
+  | { pallet: 'EmergencyParaXcm'; palletCall: PalletEmergencyParaXcmCall }
   | { pallet: 'Randomness'; palletCall: PalletRandomnessCall };
 
 export type MoonbeamRuntimeRuntimeCallLike =
@@ -1343,6 +1349,9 @@ export type MoonbeamRuntimeRuntimeCallLike =
   | { pallet: 'XcmTransactor'; palletCall: PalletXcmTransactorCallLike }
   | { pallet: 'EthereumXcm'; palletCall: PalletEthereumXcmCallLike }
   | { pallet: 'MessageQueue'; palletCall: PalletMessageQueueCallLike }
+  | { pallet: 'EvmForeignAssets'; palletCall: PalletMoonbeamForeignAssetsCallLike }
+  | { pallet: 'XcmWeightTrader'; palletCall: PalletXcmWeightTraderCallLike }
+  | { pallet: 'EmergencyParaXcm'; palletCall: PalletEmergencyParaXcmCallLike }
   | { pallet: 'Randomness'; palletCall: PalletRandomnessCallLike };
 
 /**
@@ -3778,15 +3787,13 @@ export type PalletMultisigCallLike =
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
  **/
-export type PalletMoonbeamLazyMigrationsCall = {
-  name: 'ClearSuicidedStorage';
-  params: { addresses: Array<H160>; limit: number };
-};
+export type PalletMoonbeamLazyMigrationsCall =
+  | { name: 'ClearSuicidedStorage'; params: { addresses: Array<H160>; limit: number } }
+  | { name: 'CreateContractMetadata'; params: { address: H160 } };
 
-export type PalletMoonbeamLazyMigrationsCallLike = {
-  name: 'ClearSuicidedStorage';
-  params: { addresses: Array<H160>; limit: number };
-};
+export type PalletMoonbeamLazyMigrationsCallLike =
+  | { name: 'ClearSuicidedStorage'; params: { addresses: Array<H160>; limit: number } }
+  | { name: 'CreateContractMetadata'; params: { address: H160 } };
 
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
@@ -7850,14 +7857,6 @@ export type PalletAssetManagerCall =
         isSufficient: boolean;
       };
     }
-  /**
-   * Change the amount of units we are charging per execution second
-   * for a given ForeignAssetType
-   **/
-  | {
-      name: 'SetAssetUnitsPerSecond';
-      params: { assetType: MoonbeamRuntimeXcmConfigAssetType; unitsPerSecond: bigint; numAssetsWeightHint: number };
-    }
   /**
    * Change the xcm type mapping for a given assetId
    * We also change this if the previous units per second where pointing at the old
@@ -7867,10 +7866,6 @@ export type PalletAssetManagerCall =
       name: 'ChangeExistingAssetType';
       params: { assetId: bigint; newAssetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number };
     }
-  | {
-      name: 'RemoveSupportedAsset';
-      params: { assetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number };
-    }
   /**
    * Remove a given assetId -> assetType association
    **/
@@ -7896,14 +7891,6 @@ export type PalletAssetManagerCallLike =
         isSufficient: boolean;
       };
     }
-  /**
-   * Change the amount of units we are charging per execution second
-   * for a given ForeignAssetType
-   **/
-  | {
-      name: 'SetAssetUnitsPerSecond';
-      params: { assetType: MoonbeamRuntimeXcmConfigAssetType; unitsPerSecond: bigint; numAssetsWeightHint: number };
-    }
   /**
    * Change the xcm type mapping for a given assetId
    * We also change this if the previous units per second where pointing at the old
@@ -7913,10 +7900,6 @@ export type PalletAssetManagerCallLike =
       name: 'ChangeExistingAssetType';
       params: { assetId: bigint; newAssetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number };
     }
-  | {
-      name: 'RemoveSupportedAsset';
-      params: { assetType: MoonbeamRuntimeXcmConfigAssetType; numAssetsWeightHint: number };
-    }
   /**
    * Remove a given assetId -> assetType association
    **/
@@ -8700,6 +8683,101 @@ export type CumulusPrimitivesCoreAggregateMessageOrigin =
   | { type: 'Parent' }
   | { type: 'Sibling'; value: PolkadotParachainPrimitivesPrimitivesId };
 
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletMoonbeamForeignAssetsCall =
+  /**
+   * Create new asset with the ForeignAssetCreator
+   **/
+  | {
+      name: 'CreateForeignAsset';
+      params: { assetId: bigint; xcmLocation: StagingXcmV4Location; decimals: number; symbol: Bytes; name: Bytes };
+    }
+  /**
+   * Change the xcm type mapping for a given assetId
+   * We also change this if the previous units per second where pointing at the old
+   * assetType
+   **/
+  | { name: 'ChangeXcmLocation'; params: { assetId: bigint; newXcmLocation: StagingXcmV4Location } }
+  /**
+   * Freeze a given foreign assetId
+   **/
+  | { name: 'FreezeForeignAsset'; params: { assetId: bigint; allowXcmDeposit: boolean } }
+  /**
+   * Unfreeze a given foreign assetId
+   **/
+  | { name: 'UnfreezeForeignAsset'; params: { assetId: bigint } };
+
+export type PalletMoonbeamForeignAssetsCallLike =
+  /**
+   * Create new asset with the ForeignAssetCreator
+   **/
+  | {
+      name: 'CreateForeignAsset';
+      params: {
+        assetId: bigint;
+        xcmLocation: StagingXcmV4Location;
+        decimals: number;
+        symbol: BytesLike;
+        name: BytesLike;
+      };
+    }
+  /**
+   * Change the xcm type mapping for a given assetId
+   * We also change this if the previous units per second where pointing at the old
+   * assetType
+   **/
+  | { name: 'ChangeXcmLocation'; params: { assetId: bigint; newXcmLocation: StagingXcmV4Location } }
+  /**
+   * Freeze a given foreign assetId
+   **/
+  | { name: 'FreezeForeignAsset'; params: { assetId: bigint; allowXcmDeposit: boolean } }
+  /**
+   * Unfreeze a given foreign assetId
+   **/
+  | { name: 'UnfreezeForeignAsset'; params: { assetId: bigint } };
+
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletXcmWeightTraderCall =
+  | { name: 'AddAsset'; params: { location: StagingXcmV4Location; relativePrice: bigint } }
+  | { name: 'EditAsset'; params: { location: StagingXcmV4Location; relativePrice: bigint } }
+  | { name: 'PauseAssetSupport'; params: { location: StagingXcmV4Location } }
+  | { name: 'ResumeAssetSupport'; params: { location: StagingXcmV4Location } }
+  | { name: 'RemoveAsset'; params: { location: StagingXcmV4Location } };
+
+export type PalletXcmWeightTraderCallLike =
+  | { name: 'AddAsset'; params: { location: StagingXcmV4Location; relativePrice: bigint } }
+  | { name: 'EditAsset'; params: { location: StagingXcmV4Location; relativePrice: bigint } }
+  | { name: 'PauseAssetSupport'; params: { location: StagingXcmV4Location } }
+  | { name: 'ResumeAssetSupport'; params: { location: StagingXcmV4Location } }
+  | { name: 'RemoveAsset'; params: { location: StagingXcmV4Location } };
+
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletEmergencyParaXcmCall =
+  /**
+   * Resume `Normal` mode
+   **/
+  | { name: 'PausedToNormal' }
+  /**
+   * Authorize a runtime upgrade. Only callable in `Paused` mode
+   **/
+  | { name: 'FastAuthorizeUpgrade'; params: { codeHash: H256 } };
+
+export type PalletEmergencyParaXcmCallLike =
+  /**
+   * Resume `Normal` mode
+   **/
+  | { name: 'PausedToNormal' }
+  /**
+   * Authorize a runtime upgrade. Only callable in `Paused` mode
+   **/
+  | { name: 'FastAuthorizeUpgrade'; params: { codeHash: H256 } };
+
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
  **/
@@ -9269,7 +9347,7 @@ export type PalletAssetManagerEvent =
   /**
    * Changed the amount of units we are charging per execution second for a given asset
    **/
-  | { name: 'UnitsPerSecondChanged'; data: { assetType: MoonbeamRuntimeXcmConfigAssetType; unitsPerSecond: bigint } }
+  | { name: 'UnitsPerSecondChanged' }
   /**
    * Changed the xcm type mapping for a given asset id
    **/
@@ -9489,6 +9567,59 @@ export type FrameSupportMessagesProcessMessageError =
   | { type: 'Overweight'; value: SpWeightsWeightV2Weight }
   | { type: 'Yield' };
 
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletMoonbeamForeignAssetsEvent =
+  /**
+   * New asset with the asset manager is registered
+   **/
+  | { name: 'ForeignAssetCreated'; data: { contractAddress: H160; assetId: bigint; xcmLocation: StagingXcmV4Location } }
+  /**
+   * Changed the xcm type mapping for a given asset id
+   **/
+  | { name: 'ForeignAssetXcmLocationChanged'; data: { assetId: bigint; newXcmLocation: StagingXcmV4Location } }
+  | { name: 'ForeignAssetFrozen'; data: { assetId: bigint; xcmLocation: StagingXcmV4Location } }
+  | { name: 'ForeignAssetUnfrozen'; data: { assetId: bigint; xcmLocation: StagingXcmV4Location } };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletXcmWeightTraderEvent =
+  /**
+   * New supported asset is registered
+   **/
+  | { name: 'SupportedAssetAdded'; data: { location: StagingXcmV4Location; relativePrice: bigint } }
+  /**
+   * Changed the amount of units we are charging per execution second for a given asset
+   **/
+  | { name: 'SupportedAssetEdited'; data: { location: StagingXcmV4Location; relativePrice: bigint } }
+  /**
+   * Pause support for a given asset
+   **/
+  | { name: 'PauseAssetSupport'; data: { location: StagingXcmV4Location } }
+  /**
+   * Resume support for a given asset
+   **/
+  | { name: 'ResumeAssetSupport'; data: { location: StagingXcmV4Location } }
+  /**
+   * Supported asset type for fee payment removed
+   **/
+  | { name: 'SupportedAssetRemoved'; data: { location: StagingXcmV4Location } };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletEmergencyParaXcmEvent =
+  /**
+   * The XCM incoming execution was Paused
+   **/
+  | 'EnteredPausedXcmMode'
+  /**
+   * The XCM incoming execution returned to normal operation
+   **/
+  | 'NormalXcmOperationResumed';
+
 /**
  * The `Event` enum of this pallet
  **/
@@ -10306,7 +10437,15 @@ export type PalletMoonbeamLazyMigrationsError =
   /**
    * The contract is not corrupted (Still exist or properly suicided)
    **/
-  | 'ContractNotCorrupted';
+  | 'ContractNotCorrupted'
+  /**
+   * The contract already have metadata
+   **/
+  | 'ContractMetadataAlreadySet'
+  /**
+   * Contract not exist
+   **/
+  | 'ContractNotExist';
 
 export type PalletEvmCodeMetadata = { size: bigint; hash: H256 };
 
@@ -11473,6 +11612,67 @@ export type PalletMessageQueueError =
    **/
   | 'RecursiveDisallowed';
 
+export type PalletMoonbeamForeignAssetsAssetStatus = 'Active' | 'FrozenXcmDepositAllowed' | 'FrozenXcmDepositForbidden';
+
+/**
+ * An error that can occur while executing the mapping pallet's logic.
+ **/
+export type PalletMoonbeamForeignAssetsError =
+  | 'AssetAlreadyExists'
+  | 'AssetAlreadyFrozen'
+  | 'AssetDoesNotExist'
+  | 'AssetIdFiltered'
+  | 'AssetNotFrozen'
+  | 'CorruptedStorageOrphanLocation'
+  | 'Erc20ContractCreationFail'
+  | 'EvmCallPauseFail'
+  | 'EvmCallUnpauseFail'
+  | 'EvmInternalError'
+  | 'InvalidSymbol'
+  | 'InvalidTokenName'
+  | 'LocationAlreadyExists'
+  | 'TooManyForeignAssets';
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletXcmWeightTraderError =
+  /**
+   * The given asset was already added
+   **/
+  | 'AssetAlreadyAdded'
+  /**
+   * The given asset was already paused
+   **/
+  | 'AssetAlreadyPaused'
+  /**
+   * The given asset was not found
+   **/
+  | 'AssetNotFound'
+  /**
+   * The given asset is not paused
+   **/
+  | 'AssetNotPaused'
+  /**
+   * XCM location filtered
+   **/
+  | 'XcmLocationFiltered'
+  /**
+   * The relative price cannot be zero
+   **/
+  | 'PriceCannotBeZero';
+
+export type PalletEmergencyParaXcmXcmMode = 'Normal' | 'Paused';
+
+/**
+ * An error that can occur while executing this pallet's extrinsics.
+ **/
+export type PalletEmergencyParaXcmError =
+  /**
+   * The current XCM Mode is not Paused
+   **/
+  'NotInPausedMode';
+
 /**
  * The `Error` enum of this pallet.
  **/
@@ -11531,6 +11731,12 @@ export type FrameSystemExtensionsCheckWeight = {};
 
 export type PalletTransactionPaymentChargeTransactionPayment = bigint;
 
+export type FrameMetadataHashExtensionCheckMetadataHash = { mode: FrameMetadataHashExtensionMode };
+
+export type FrameMetadataHashExtensionMode = 'Disabled' | 'Enabled';
+
+export type CumulusPrimitivesStorageWeightReclaimStorageWeightReclaim = {};
+
 export type MoonbeamRuntimeRuntime = {};
 
 export type SpRuntimeTransactionValidityTransactionSource = 'InBlock' | 'Local' | 'External';
@@ -11677,5 +11883,8 @@ export type MoonbeamRuntimeRuntimeError =
   | { pallet: 'XcmTransactor'; palletError: PalletXcmTransactorError }
   | { pallet: 'EthereumXcm'; palletError: PalletEthereumXcmError }
   | { pallet: 'MessageQueue'; palletError: PalletMessageQueueError }
+  | { pallet: 'EvmForeignAssets'; palletError: PalletMoonbeamForeignAssetsError }
+  | { pallet: 'XcmWeightTrader'; palletError: PalletXcmWeightTraderError }
+  | { pallet: 'EmergencyParaXcm'; palletError: PalletEmergencyParaXcmError }
   | { pallet: 'PrecompileBenchmarks'; palletError: PalletPrecompileBenchmarksError }
   | { pallet: 'Randomness'; palletError: PalletRandomnessError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/chaintypes",
-  "version": "0.31.0",
+  "version": "0.33.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": "1d615507a4bebe0d533f5c74be6c20df1c422559",
+  "gitHead": "e0e11e70e46a362d520c53417db80e73f5d6fc53",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

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

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