@dedot/chaintypes 0.136.0 → 0.138.0

package/paseo-hydration/types.d.ts

@@ -113,6 +113,10 @@ export type HydradxRuntimeRuntimeEvent =
   | { pallet: 'UnknownTokens'; palletEvent: OrmlUnknownTokensModuleEvent }
   | { pallet: 'CollatorSelection'; palletEvent: PalletCollatorSelectionEvent }
   | { pallet: 'Session'; palletEvent: PalletSessionEvent }
+  | { pallet: 'Ismp'; palletEvent: PalletIsmpEvent }
+  | { pallet: 'IsmpParachain'; palletEvent: IsmpParachainEvent }
+  | { pallet: 'Hyperbridge'; palletEvent: PalletHyperbridgeEvent }
+  | { pallet: 'TokenGateway'; palletEvent: PalletTokenGatewayEvent }
   | { pallet: 'EmaOracle'; palletEvent: PalletEmaOracleEvent }
   | { pallet: 'Broadcast'; palletEvent: PalletBroadcastEvent };
 
@@ -1308,6 +1312,9 @@ export type HydradxRuntimeRuntimeCall =
   | { pallet: 'XTokens'; palletCall: OrmlXtokensModuleCall }
   | { pallet: 'CollatorSelection'; palletCall: PalletCollatorSelectionCall }
   | { pallet: 'Session'; palletCall: PalletSessionCall }
+  | { pallet: 'Ismp'; palletCall: PalletIsmpCall }
+  | { pallet: 'IsmpParachain'; palletCall: IsmpParachainCall }
+  | { pallet: 'TokenGateway'; palletCall: PalletTokenGatewayCall }
   | { pallet: 'EmaOracle'; palletCall: PalletEmaOracleCall }
   | { pallet: 'Broadcast'; palletCall: PalletBroadcastCall };
 
@@ -1371,6 +1378,9 @@ export type HydradxRuntimeRuntimeCallLike =
   | { pallet: 'XTokens'; palletCall: OrmlXtokensModuleCallLike }
   | { pallet: 'CollatorSelection'; palletCall: PalletCollatorSelectionCallLike }
   | { pallet: 'Session'; palletCall: PalletSessionCallLike }
+  | { pallet: 'Ismp'; palletCall: PalletIsmpCallLike }
+  | { pallet: 'IsmpParachain'; palletCall: IsmpParachainCallLike }
+  | { pallet: 'TokenGateway'; palletCall: PalletTokenGatewayCallLike }
   | { pallet: 'EmaOracle'; palletCall: PalletEmaOracleCallLike }
   | { pallet: 'Broadcast'; palletCall: PalletBroadcastCallLike };
 
@@ -6082,7 +6092,19 @@ export type PalletDispatcherCall =
    * This allows executing calls with additional weight (gas) limit.
    * The extra gas is not refunded, even if not used.
    **/
-  | { name: 'DispatchWithExtraGas'; params: { call: HydradxRuntimeRuntimeCall; extraGas: bigint } };
+  | { name: 'DispatchWithExtraGas'; params: { call: HydradxRuntimeRuntimeCall; extraGas: bigint } }
+  /**
+   * Execute a single EVM call.
+   * This extrinsic will fail if the EVM call returns any other ExitReason than `ExitSucceed(Returned)` or `ExitSucceed(Stopped)`.
+   * Look the [hydradx_runtime::evm::runner::WrapRunner] implementation for details.
+   *
+   * Parameters:
+   * - `origin`: Signed origin.
+   * - `call`: presumably `pallet_evm::Call::call` as boxed `RuntimeCall`.
+   *
+   * Emits `EvmCallFailed` event when failed.
+   **/
+  | { name: 'DispatchEvmCall'; params: { call: HydradxRuntimeRuntimeCall } };
 
 export type PalletDispatcherCallLike =
   | { name: 'DispatchAsTreasury'; params: { call: HydradxRuntimeRuntimeCallLike } }
@@ -6102,7 +6124,19 @@ export type PalletDispatcherCallLike =
    * This allows executing calls with additional weight (gas) limit.
    * The extra gas is not refunded, even if not used.
    **/
-  | { name: 'DispatchWithExtraGas'; params: { call: HydradxRuntimeRuntimeCallLike; extraGas: bigint } };
+  | { name: 'DispatchWithExtraGas'; params: { call: HydradxRuntimeRuntimeCallLike; extraGas: bigint } }
+  /**
+   * Execute a single EVM call.
+   * This extrinsic will fail if the EVM call returns any other ExitReason than `ExitSucceed(Returned)` or `ExitSucceed(Stopped)`.
+   * Look the [hydradx_runtime::evm::runner::WrapRunner] implementation for details.
+   *
+   * Parameters:
+   * - `origin`: Signed origin.
+   * - `call`: presumably `pallet_evm::Call::call` as boxed `RuntimeCall`.
+   *
+   * Emits `EvmCallFailed` event when failed.
+   **/
+  | { name: 'DispatchEvmCall'; params: { call: HydradxRuntimeRuntimeCallLike } };
 
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
@@ -8100,7 +8134,7 @@ export type PalletDynamicFeesCall =
    * This function allows setting either fixed or dynamic fee configuration for a specific asset.
    *
    * # Arguments
-   * * `origin` - Root origin required
+   * * `origin` - Authority origin required
    * * `asset_id` - The asset ID to configure
    * * `config` - Fee configuration (Fixed or Dynamic)
    **/
@@ -8112,7 +8146,7 @@ export type PalletDynamicFeesCall =
    * After removal, the asset will use the default dynamic fee parameters configured in the runtime.
    *
    * # Arguments
-   * * `origin` - Root origin required
+   * * `origin` - Authority origin required
    * * `asset_id` - The asset ID to remove configuration for
    **/
   | { name: 'RemoveAssetFee'; params: { assetId: number } };
@@ -8124,7 +8158,7 @@ export type PalletDynamicFeesCallLike =
    * This function allows setting either fixed or dynamic fee configuration for a specific asset.
    *
    * # Arguments
-   * * `origin` - Root origin required
+   * * `origin` - Authority origin required
    * * `asset_id` - The asset ID to configure
    * * `config` - Fee configuration (Fixed or Dynamic)
    **/
@@ -8136,7 +8170,7 @@ export type PalletDynamicFeesCallLike =
    * After removal, the asset will use the default dynamic fee parameters configured in the runtime.
    *
    * # Arguments
-   * * `origin` - Root origin required
+   * * `origin` - Authority origin required
    * * `asset_id` - The asset ID to remove configuration for
    **/
   | { name: 'RemoveAssetFee'; params: { assetId: number } };
@@ -9695,6 +9729,7 @@ export type PalletReferralsFeeDistribution = { referrer: Permill; trader: Permil
 export type PalletLiquidationCall =
   /**
    * Liquidates an existing money market position.
+   * Can be both signed and unsigned.
    *
    * Performs a flash loan to get funds to pay for the debt.
    * Received collateral is swapped and the profit is transferred to `FeeReceiver`.
@@ -9728,6 +9763,7 @@ export type PalletLiquidationCall =
 export type PalletLiquidationCallLike =
   /**
    * Liquidates an existing money market position.
+   * Can be both signed and unsigned.
    *
    * Performs a flash loan to get funds to pay for the debt.
    * Received collateral is swapped and the profit is transferred to `FeeReceiver`.
@@ -9934,7 +9970,7 @@ export type PalletHsmCall =
    * - `InvalidEVMInteraction` if there's an error interacting with the Hollar ERC20 contract
    * - Other errors from underlying calls
    **/
-  | { name: 'ExecuteArbitrage'; params: { collateralAssetId: number } }
+  | { name: 'ExecuteArbitrage'; params: { collateralAssetId: number; flashAmount?: bigint | undefined } }
   | { name: 'SetFlashMinter'; params: { flashMinterAddr: H160 } };
 
 export type PalletHsmCallLike =
@@ -10110,7 +10146,7 @@ export type PalletHsmCallLike =
    * - `InvalidEVMInteraction` if there's an error interacting with the Hollar ERC20 contract
    * - Other errors from underlying calls
    **/
-  | { name: 'ExecuteArbitrage'; params: { collateralAssetId: number } }
+  | { name: 'ExecuteArbitrage'; params: { collateralAssetId: number; flashAmount?: bigint | undefined } }
   | { name: 'SetFlashMinter'; params: { flashMinterAddr: H160 } };
 
 /**
@@ -13602,6 +13638,323 @@ export type HydradxRuntimeOpaqueSessionKeys = { aura: SpConsensusAuraSr25519AppS
 
 export type SpConsensusAuraSr25519AppSr25519Public = FixedBytes<32>;
 
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletIsmpCall =
+  /**
+   * Execute the provided batch of ISMP messages, this will short-circuit and revert if any
+   * of the provided messages are invalid. This is an unsigned extrinsic that permits anyone
+   * execute ISMP messages for free, provided they have valid proofs and the messages have
+   * not been previously processed.
+   *
+   * The dispatch origin for this call must be an unsigned one.
+   *
+   * - `messages`: the messages to handle or process.
+   *
+   * Emits different message events based on the Message received if successful.
+   **/
+  | { name: 'HandleUnsigned'; params: { messages: Array<IsmpMessagingMessage> } }
+  /**
+   * Create a consensus client, using a subjectively chosen consensus state. This can also
+   * be used to overwrite an existing consensus state. The dispatch origin for this
+   * call must be `T::AdminOrigin`.
+   *
+   * - `message`: [`CreateConsensusState`] struct.
+   *
+   * Emits [`Event::ConsensusClientCreated`] if successful.
+   **/
+  | { name: 'CreateConsensusClient'; params: { message: IsmpMessagingCreateConsensusState } }
+  /**
+   * Modify the unbonding period and challenge period for a consensus state.
+   * The dispatch origin for this call must be `T::AdminOrigin`.
+   *
+   * - `message`: `UpdateConsensusState` struct.
+   **/
+  | { name: 'UpdateConsensusState'; params: { message: PalletIsmpUtilsUpdateConsensusState } }
+  /**
+   * Add more funds to a message (request or response) to be used for delivery and execution.
+   *
+   * Should not be called on a message that has been completed (delivered or timed-out) as
+   * those funds will be lost forever.
+   **/
+  | { name: 'FundMessage'; params: { message: PalletIsmpUtilsFundMessageParams } };
+
+export type PalletIsmpCallLike =
+  /**
+   * Execute the provided batch of ISMP messages, this will short-circuit and revert if any
+   * of the provided messages are invalid. This is an unsigned extrinsic that permits anyone
+   * execute ISMP messages for free, provided they have valid proofs and the messages have
+   * not been previously processed.
+   *
+   * The dispatch origin for this call must be an unsigned one.
+   *
+   * - `messages`: the messages to handle or process.
+   *
+   * Emits different message events based on the Message received if successful.
+   **/
+  | { name: 'HandleUnsigned'; params: { messages: Array<IsmpMessagingMessage> } }
+  /**
+   * Create a consensus client, using a subjectively chosen consensus state. This can also
+   * be used to overwrite an existing consensus state. The dispatch origin for this
+   * call must be `T::AdminOrigin`.
+   *
+   * - `message`: [`CreateConsensusState`] struct.
+   *
+   * Emits [`Event::ConsensusClientCreated`] if successful.
+   **/
+  | { name: 'CreateConsensusClient'; params: { message: IsmpMessagingCreateConsensusState } }
+  /**
+   * Modify the unbonding period and challenge period for a consensus state.
+   * The dispatch origin for this call must be `T::AdminOrigin`.
+   *
+   * - `message`: `UpdateConsensusState` struct.
+   **/
+  | { name: 'UpdateConsensusState'; params: { message: PalletIsmpUtilsUpdateConsensusState } }
+  /**
+   * Add more funds to a message (request or response) to be used for delivery and execution.
+   *
+   * Should not be called on a message that has been completed (delivered or timed-out) as
+   * those funds will be lost forever.
+   **/
+  | { name: 'FundMessage'; params: { message: PalletIsmpUtilsFundMessageParams } };
+
+export type IsmpMessagingMessage =
+  | { type: 'Consensus'; value: IsmpMessagingConsensusMessage }
+  | { type: 'FraudProof'; value: IsmpMessagingFraudProofMessage }
+  | { type: 'Request'; value: IsmpMessagingRequestMessage }
+  | { type: 'Response'; value: IsmpMessagingResponseMessage }
+  | { type: 'Timeout'; value: IsmpMessagingTimeoutMessage };
+
+export type IsmpMessagingConsensusMessage = { consensusProof: Bytes; consensusStateId: FixedBytes<4>; signer: Bytes };
+
+export type IsmpMessagingFraudProofMessage = { proof1: Bytes; proof2: Bytes; consensusStateId: FixedBytes<4> };
+
+export type IsmpMessagingRequestMessage = {
+  requests: Array<IsmpRouterPostRequest>;
+  proof: IsmpMessagingProof;
+  signer: Bytes;
+};
+
+export type IsmpRouterPostRequest = {
+  source: IsmpHostStateMachine;
+  dest: IsmpHostStateMachine;
+  nonce: bigint;
+  from: Bytes;
+  to: Bytes;
+  timeoutTimestamp: bigint;
+  body: Bytes;
+};
+
+export type IsmpHostStateMachine =
+  | { type: 'Evm'; value: number }
+  | { type: 'Polkadot'; value: number }
+  | { type: 'Kusama'; value: number }
+  | { type: 'Substrate'; value: FixedBytes<4> }
+  | { type: 'Tendermint'; value: FixedBytes<4> };
+
+export type IsmpMessagingProof = { height: IsmpConsensusStateMachineHeight; proof: Bytes };
+
+export type IsmpConsensusStateMachineHeight = { id: IsmpConsensusStateMachineId; height: bigint };
+
+export type IsmpConsensusStateMachineId = { stateId: IsmpHostStateMachine; consensusStateId: FixedBytes<4> };
+
+export type IsmpMessagingResponseMessage = {
+  datagram: IsmpRouterRequestResponse;
+  proof: IsmpMessagingProof;
+  signer: Bytes;
+};
+
+export type IsmpRouterRequestResponse =
+  | { type: 'Request'; value: Array<IsmpRouterRequest> }
+  | { type: 'Response'; value: Array<IsmpRouterResponse> };
+
+export type IsmpRouterRequest =
+  | { type: 'Post'; value: IsmpRouterPostRequest }
+  | { type: 'Get'; value: IsmpRouterGetRequest };
+
+export type IsmpRouterGetRequest = {
+  source: IsmpHostStateMachine;
+  dest: IsmpHostStateMachine;
+  nonce: bigint;
+  from: Bytes;
+  keys: Array<Bytes>;
+  height: bigint;
+  context: Bytes;
+  timeoutTimestamp: bigint;
+};
+
+export type IsmpRouterResponse =
+  | { type: 'Post'; value: IsmpRouterPostResponse }
+  | { type: 'Get'; value: IsmpRouterGetResponse };
+
+export type IsmpRouterPostResponse = { post: IsmpRouterPostRequest; response: Bytes; timeoutTimestamp: bigint };
+
+export type IsmpRouterGetResponse = { get: IsmpRouterGetRequest; values: Array<IsmpRouterStorageValue> };
+
+export type IsmpRouterStorageValue = { key: Bytes; value?: Bytes | undefined };
+
+export type IsmpMessagingTimeoutMessage =
+  | { type: 'Post'; value: { requests: Array<IsmpRouterRequest>; timeoutProof: IsmpMessagingProof } }
+  | { type: 'PostResponse'; value: { responses: Array<IsmpRouterPostResponse>; timeoutProof: IsmpMessagingProof } }
+  | { type: 'Get'; value: { requests: Array<IsmpRouterRequest> } };
+
+export type IsmpMessagingCreateConsensusState = {
+  consensusState: Bytes;
+  consensusClientId: FixedBytes<4>;
+  consensusStateId: FixedBytes<4>;
+  unbondingPeriod: bigint;
+  challengePeriods: Array<[IsmpHostStateMachine, bigint]>;
+  stateMachineCommitments: Array<[IsmpConsensusStateMachineId, IsmpMessagingStateCommitmentHeight]>;
+};
+
+export type IsmpMessagingStateCommitmentHeight = { commitment: IsmpConsensusStateCommitment; height: bigint };
+
+export type IsmpConsensusStateCommitment = { timestamp: bigint; overlayRoot?: H256 | undefined; stateRoot: H256 };
+
+export type PalletIsmpUtilsUpdateConsensusState = {
+  consensusStateId: FixedBytes<4>;
+  unbondingPeriod?: bigint | undefined;
+  challengePeriods: Array<[IsmpHostStateMachine, bigint]>;
+};
+
+export type PalletIsmpUtilsFundMessageParams = { commitment: PalletIsmpUtilsMessageCommitment; amount: bigint };
+
+export type PalletIsmpUtilsMessageCommitment = { type: 'Request'; value: H256 } | { type: 'Response'; value: H256 };
+
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type IsmpParachainCall =
+  /**
+   * This allows block builders submit parachain consensus proofs as inherents. If the
+   * provided [`ConsensusMessage`] is not for a parachain, this call will fail.
+   **/
+  | { name: 'UpdateParachainConsensus'; params: { data: IsmpMessagingConsensusMessage } }
+  /**
+   * Add some new parachains to the parachains whitelist
+   **/
+  | { name: 'AddParachain'; params: { paraIds: Array<IsmpParachainParachainData> } }
+  /**
+   * Removes some parachains from the parachains whitelist
+   **/
+  | { name: 'RemoveParachain'; params: { paraIds: Array<number> } };
+
+export type IsmpParachainCallLike =
+  /**
+   * This allows block builders submit parachain consensus proofs as inherents. If the
+   * provided [`ConsensusMessage`] is not for a parachain, this call will fail.
+   **/
+  | { name: 'UpdateParachainConsensus'; params: { data: IsmpMessagingConsensusMessage } }
+  /**
+   * Add some new parachains to the parachains whitelist
+   **/
+  | { name: 'AddParachain'; params: { paraIds: Array<IsmpParachainParachainData> } }
+  /**
+   * Removes some parachains from the parachains whitelist
+   **/
+  | { name: 'RemoveParachain'; params: { paraIds: Array<number> } };
+
+export type IsmpParachainParachainData = { id: number; slotDuration: bigint };
+
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletTokenGatewayCall =
+  /**
+   * Teleports a registered asset
+   * locks the asset and dispatches a request to token gateway on the destination
+   **/
+  | { name: 'Teleport'; params: { params: PalletTokenGatewayTeleportParams } }
+  /**
+   * Set the token gateway address for specified chains
+   **/
+  | { name: 'SetTokenGatewayAddresses'; params: { addresses: Array<[IsmpHostStateMachine, Bytes]> } }
+  /**
+   * Registers a multi-chain ERC6160 asset. The asset should not already exist.
+   *
+   * This works by dispatching a request to the TokenGateway module on each requested chain
+   * to create the asset.
+   * `native` should be true if this asset originates from this chain
+   **/
+  | { name: 'CreateErc6160Asset'; params: { asset: PalletTokenGatewayAssetRegistration } }
+  /**
+   * Registers a multi-chain ERC6160 asset. The asset should not already exist.
+   *
+   * This works by dispatching a request to the TokenGateway module on each requested chain
+   * to create the asset.
+   **/
+  | { name: 'UpdateErc6160Asset'; params: { asset: TokenGatewayPrimitivesGatewayAssetUpdate } }
+  /**
+   * Update the precision for an existing asset
+   **/
+  | { name: 'UpdateAssetPrecision'; params: { update: PalletTokenGatewayPrecisionUpdate } };
+
+export type PalletTokenGatewayCallLike =
+  /**
+   * Teleports a registered asset
+   * locks the asset and dispatches a request to token gateway on the destination
+   **/
+  | { name: 'Teleport'; params: { params: PalletTokenGatewayTeleportParams } }
+  /**
+   * Set the token gateway address for specified chains
+   **/
+  | { name: 'SetTokenGatewayAddresses'; params: { addresses: Array<[IsmpHostStateMachine, BytesLike]> } }
+  /**
+   * Registers a multi-chain ERC6160 asset. The asset should not already exist.
+   *
+   * This works by dispatching a request to the TokenGateway module on each requested chain
+   * to create the asset.
+   * `native` should be true if this asset originates from this chain
+   **/
+  | { name: 'CreateErc6160Asset'; params: { asset: PalletTokenGatewayAssetRegistration } }
+  /**
+   * Registers a multi-chain ERC6160 asset. The asset should not already exist.
+   *
+   * This works by dispatching a request to the TokenGateway module on each requested chain
+   * to create the asset.
+   **/
+  | { name: 'UpdateErc6160Asset'; params: { asset: TokenGatewayPrimitivesGatewayAssetUpdate } }
+  /**
+   * Update the precision for an existing asset
+   **/
+  | { name: 'UpdateAssetPrecision'; params: { update: PalletTokenGatewayPrecisionUpdate } };
+
+export type PalletTokenGatewayTeleportParams = {
+  assetId: number;
+  destination: IsmpHostStateMachine;
+  recepient: H256;
+  amount: bigint;
+  timeout: bigint;
+  tokenGateway: Bytes;
+  relayerFee: bigint;
+  callData?: Bytes | undefined;
+  redeem: boolean;
+};
+
+export type PalletTokenGatewayAssetRegistration = {
+  localId: number;
+  reg: TokenGatewayPrimitivesGatewayAssetRegistration;
+  native: boolean;
+  precision: Array<[IsmpHostStateMachine, number]>;
+};
+
+export type TokenGatewayPrimitivesGatewayAssetRegistration = {
+  name: Bytes;
+  symbol: Bytes;
+  chains: Array<IsmpHostStateMachine>;
+  minimumBalance?: bigint | undefined;
+};
+
+export type TokenGatewayPrimitivesGatewayAssetUpdate = {
+  assetId: H256;
+  addChains: Array<IsmpHostStateMachine>;
+  removeChains: Array<IsmpHostStateMachine>;
+  newAdmins: Array<[IsmpHostStateMachine, H160]>;
+};
+
+export type PalletTokenGatewayPrecisionUpdate = { assetId: number; precisions: Array<[IsmpHostStateMachine, number]> };
+
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
  **/
@@ -14524,9 +14877,8 @@ export type PalletHsmEvent =
    *
    * Parameters:
    * - `asset_id`: The ID of the asset removed from collaterals
-   * - `amount`: The amount of the asset that was returned (should be zero)
    **/
-  | { name: 'CollateralRemoved'; data: { assetId: number; amount: bigint } }
+  | { name: 'CollateralRemoved'; data: { assetId: number } }
   /**
    * A collateral asset was updated
    *
@@ -15477,6 +15829,356 @@ export type PalletSessionEvent =
    **/
   { name: 'NewSession'; data: { sessionIndex: number } };
 
+/**
+ * Pallet Events
+ **/
+export type PalletIsmpEvent =
+  /**
+   * Emitted when a state machine is successfully updated to a new height
+   **/
+  | {
+      name: 'StateMachineUpdated';
+      data: {
+        /**
+         * State machine identifier
+         **/
+        stateMachineId: IsmpConsensusStateMachineId;
+
+        /**
+         * State machine latest height
+         **/
+        latestHeight: bigint;
+      };
+    }
+  /**
+   * Emitted when a state commitment is vetoed by a fisherman
+   **/
+  | {
+      name: 'StateCommitmentVetoed';
+      data: {
+        /**
+         * State machine height
+         **/
+        height: IsmpConsensusStateMachineHeight;
+
+        /**
+         * responsible fisherman
+         **/
+        fisherman: Bytes;
+      };
+    }
+  /**
+   * Indicates that a consensus client has been created
+   **/
+  | {
+      name: 'ConsensusClientCreated';
+      data: {
+        /**
+         * Consensus client id
+         **/
+        consensusClientId: FixedBytes<4>;
+      };
+    }
+  /**
+   * Indicates that a consensus client has been created
+   **/
+  | {
+      name: 'ConsensusClientFrozen';
+      data: {
+        /**
+         * Consensus client id
+         **/
+        consensusClientId: FixedBytes<4>;
+      };
+    }
+  /**
+   * An Outgoing Response has been deposited
+   **/
+  | {
+      name: 'Response';
+      data: {
+        /**
+         * Chain that this response will be routed to
+         **/
+        destChain: IsmpHostStateMachine;
+
+        /**
+         * Source Chain for this response
+         **/
+        sourceChain: IsmpHostStateMachine;
+
+        /**
+         * Nonce for the request which this response is for
+         **/
+        requestNonce: bigint;
+
+        /**
+         * Response Commitment
+         **/
+        commitment: H256;
+
+        /**
+         * Request commitment
+         **/
+        reqCommitment: H256;
+      };
+    }
+  /**
+   * An Outgoing Request has been deposited
+   **/
+  | {
+      name: 'Request';
+      data: {
+        /**
+         * Chain that this request will be routed to
+         **/
+        destChain: IsmpHostStateMachine;
+
+        /**
+         * Source Chain for request
+         **/
+        sourceChain: IsmpHostStateMachine;
+
+        /**
+         * Request nonce
+         **/
+        requestNonce: bigint;
+
+        /**
+         * Commitment
+         **/
+        commitment: H256;
+      };
+    }
+  /**
+   * Some errors handling some ismp messages
+   **/
+  | {
+      name: 'Errors';
+      data: {
+        /**
+         * Message handling errors
+         **/
+        errors: Array<PalletIsmpErrorsHandlingError>;
+      };
+    }
+  /**
+   * Post Request Handled
+   **/
+  | { name: 'PostRequestHandled'; data: IsmpEventsRequestResponseHandled }
+  /**
+   * Post Response Handled
+   **/
+  | { name: 'PostResponseHandled'; data: IsmpEventsRequestResponseHandled }
+  /**
+   * Get Response Handled
+   **/
+  | { name: 'GetRequestHandled'; data: IsmpEventsRequestResponseHandled }
+  /**
+   * Post request timeout handled
+   **/
+  | { name: 'PostRequestTimeoutHandled'; data: IsmpEventsTimeoutHandled }
+  /**
+   * Post response timeout handled
+   **/
+  | { name: 'PostResponseTimeoutHandled'; data: IsmpEventsTimeoutHandled }
+  /**
+   * Get request timeout handled
+   **/
+  | { name: 'GetRequestTimeoutHandled'; data: IsmpEventsTimeoutHandled };
+
+export type PalletIsmpErrorsHandlingError = { message: Bytes };
+
+export type IsmpEventsRequestResponseHandled = { commitment: H256; relayer: Bytes };
+
+export type IsmpEventsTimeoutHandled = { commitment: H256; source: IsmpHostStateMachine; dest: IsmpHostStateMachine };
+
+/**
+ * Events emitted by this pallet
+ **/
+export type IsmpParachainEvent =
+  /**
+   * Parachains with the `para_ids` have been added to the whitelist
+   **/
+  | {
+      name: 'ParachainsAdded';
+      data: {
+        /**
+         * The parachains in question
+         **/
+        paraIds: Array<IsmpParachainParachainData>;
+      };
+    }
+  /**
+   * Parachains with the `para_ids` have been removed from the whitelist
+   **/
+  | {
+      name: 'ParachainsRemoved';
+      data: {
+        /**
+         * The parachains in question
+         **/
+        paraIds: Array<number>;
+      };
+    };
+
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletHyperbridgeEvent =
+  /**
+   * Hyperbridge governance has now updated it's host params on this chain.
+   **/
+  | {
+      name: 'HostParamsUpdated';
+      data: {
+        /**
+         * The old host params
+         **/
+        old: PalletHyperbridgeVersionedHostParams;
+
+        /**
+         * The new host params
+         **/
+        new: PalletHyperbridgeVersionedHostParams;
+      };
+    }
+  /**
+   * A relayer has withdrawn some fees
+   **/
+  | {
+      name: 'RelayerFeeWithdrawn';
+      data: {
+        /**
+         * The amount that was withdrawn
+         **/
+        amount: bigint;
+
+        /**
+         * The withdrawal beneficiary
+         **/
+        account: AccountId32;
+      };
+    }
+  /**
+   * Hyperbridge has withdrawn it's protocol revenue
+   **/
+  | {
+      name: 'ProtocolRevenueWithdrawn';
+      data: {
+        /**
+         * The amount that was withdrawn
+         **/
+        amount: bigint;
+
+        /**
+         * The withdrawal beneficiary
+         **/
+        account: AccountId32;
+      };
+    };
+
+export type PalletHyperbridgeVersionedHostParams = { type: 'V1'; value: PalletHyperbridgeSubstrateHostParams };
+
+export type PalletHyperbridgeSubstrateHostParams = {
+  defaultPerByteFee: bigint;
+  perByteFees: Array<[IsmpHostStateMachine, bigint]>;
+  assetRegistrationFee: bigint;
+};
+
+/**
+ * Pallet events that functions in this pallet can emit.
+ **/
+export type PalletTokenGatewayEvent =
+  /**
+   * An asset has been teleported
+   **/
+  | {
+      name: 'AssetTeleported';
+      data: {
+        /**
+         * Source account
+         **/
+        from: AccountId32;
+
+        /**
+         * beneficiary account on destination
+         **/
+        to: H256;
+
+        /**
+         * Amount transferred
+         **/
+        amount: bigint;
+
+        /**
+         * Destination chain
+         **/
+        dest: IsmpHostStateMachine;
+
+        /**
+         * Request commitment
+         **/
+        commitment: H256;
+      };
+    }
+  /**
+   * An asset has been received and transferred to the beneficiary's account
+   **/
+  | {
+      name: 'AssetReceived';
+      data: {
+        /**
+         * beneficiary account on relaychain
+         **/
+        beneficiary: AccountId32;
+
+        /**
+         * Amount transferred
+         **/
+        amount: bigint;
+
+        /**
+         * Destination chain
+         **/
+        source: IsmpHostStateMachine;
+      };
+    }
+  /**
+   * An asset has been refunded and transferred to the beneficiary's account
+   **/
+  | {
+      name: 'AssetRefunded';
+      data: {
+        /**
+         * beneficiary account on relaychain
+         **/
+        beneficiary: AccountId32;
+
+        /**
+         * Amount transferred
+         **/
+        amount: bigint;
+
+        /**
+         * Destination chain
+         **/
+        source: IsmpHostStateMachine;
+      };
+    }
+  /**
+   * ERC6160 asset creation request dispatched to hyperbridge
+   **/
+  | {
+      name: 'Erc6160AssetRegistrationDispatched';
+      data: {
+        /**
+         * Request commitment
+         **/
+        commitment: H256;
+      };
+    };
+
 /**
  * The `Event` enum of this pallet
  **/
@@ -16612,6 +17314,20 @@ export type PalletWhitelistError =
    **/
   | 'CallAlreadyWhitelisted';
 
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletDispatcherError =
+  /**
+   * The EVM call execution failed. This happens when the EVM returns an exit reason
+   * other than `ExitSucceed(Returned)` or `ExitSucceed(Stopped)`.
+   **/
+  | 'EvmCallFailed'
+  /**
+   * The provided call is not an EVM call. This extrinsic only accepts `pallet_evm::Call::call`.
+   **/
+  | 'NotEvmCall';
+
 export type PalletAssetRegistryAssetDetails = {
   name?: Bytes | undefined;
   assetType: PalletAssetRegistryAssetType;
@@ -19025,6 +19741,77 @@ export type PalletSessionError =
 
 export type SpConsensusSlotsSlot = bigint;
 
+/**
+ * Pallet errors
+ **/
+export type PalletIsmpError =
+  /**
+   * Invalid ISMP message
+   **/
+  | 'InvalidMessage'
+  /**
+   * Requested message was not found
+   **/
+  | 'MessageNotFound'
+  /**
+   * Encountered an error while creating the consensus client.
+   **/
+  | 'ConsensusClientCreationFailed'
+  /**
+   * Couldn't update unbonding period
+   **/
+  | 'UnbondingPeriodUpdateFailed'
+  /**
+   * Couldn't update challenge period
+   **/
+  | 'ChallengePeriodUpdateFailed';
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletHyperbridgeError = null;
+
+/**
+ * Errors that can be returned by this pallet.
+ **/
+export type PalletTokenGatewayError =
+  /**
+   * A asset that has not been registered
+   **/
+  | 'UnregisteredAsset'
+  /**
+   * Error while teleporting asset
+   **/
+  | 'AssetTeleportError'
+  /**
+   * Coprocessor was not configured in the runtime
+   **/
+  | 'CoprocessorNotConfigured'
+  /**
+   * Asset or update Dispatch Error
+   **/
+  | 'DispatchError'
+  /**
+   * Asset Id creation failed
+   **/
+  | 'AssetCreationError'
+  /**
+   * Asset decimals not found
+   **/
+  | 'AssetDecimalsNotFound'
+  /**
+   * Protocol Params have not been initialized
+   **/
+  | 'NotInitialized'
+  /**
+   * Unknown Asset
+   **/
+  | 'UnknownAsset'
+  /**
+   * Only root or asset owner can update asset
+   **/
+  | 'NotAssetOwner';
+
 export type PalletEmaOracleOracleEntry = {
   price: HydraDxMathRatio;
   volume: HydradxTraitsOracleVolume;
@@ -19225,6 +20012,26 @@ export type HydradxRuntimeEvmAaveTradeExecutorPoolData = {
   liqudityOut: bigint;
 };
 
+export type IsmpEventsEvent =
+  | { type: 'StateMachineUpdated'; value: IsmpEventsStateMachineUpdated }
+  | { type: 'StateCommitmentVetoed'; value: IsmpEventsStateCommitmentVetoed }
+  | { type: 'PostRequest'; value: IsmpRouterPostRequest }
+  | { type: 'PostResponse'; value: IsmpRouterPostResponse }
+  | { type: 'GetResponse'; value: IsmpRouterGetResponse }
+  | { type: 'GetRequest'; value: IsmpRouterGetRequest }
+  | { type: 'PostRequestHandled'; value: IsmpEventsRequestResponseHandled }
+  | { type: 'PostResponseHandled'; value: IsmpEventsRequestResponseHandled }
+  | { type: 'PostRequestTimeoutHandled'; value: IsmpEventsTimeoutHandled }
+  | { type: 'PostResponseTimeoutHandled'; value: IsmpEventsTimeoutHandled }
+  | { type: 'GetRequestHandled'; value: IsmpEventsRequestResponseHandled }
+  | { type: 'GetRequestTimeoutHandled'; value: IsmpEventsTimeoutHandled };
+
+export type IsmpEventsStateMachineUpdated = { stateMachineId: IsmpConsensusStateMachineId; latestHeight: bigint };
+
+export type IsmpEventsStateCommitmentVetoed = { height: IsmpConsensusStateMachineHeight; fisherman: Bytes };
+
+export type CumulusPalletParachainSystemRelayChainState = { number: number; stateRoot: H256 };
+
 export type HydradxRuntimeRuntimeError =
   | { pallet: 'System'; palletError: FrameSystemError }
   | { pallet: 'Balances'; palletError: PalletBalancesError }
@@ -19242,6 +20049,7 @@ export type HydradxRuntimeRuntimeError =
   | { pallet: 'ConvictionVoting'; palletError: PalletConvictionVotingError }
   | { pallet: 'Referenda'; palletError: PalletReferendaError }
   | { pallet: 'Whitelist'; palletError: PalletWhitelistError }
+  | { pallet: 'Dispatcher'; palletError: PalletDispatcherError }
   | { pallet: 'AssetRegistry'; palletError: PalletAssetRegistryError }
   | { pallet: 'Claims'; palletError: PalletClaimsError }
   | { pallet: 'CollatorRewards'; palletError: PalletCollatorRewardsError }
@@ -19283,5 +20091,8 @@ export type HydradxRuntimeRuntimeError =
   | { pallet: 'UnknownTokens'; palletError: OrmlUnknownTokensModuleError }
   | { pallet: 'CollatorSelection'; palletError: PalletCollatorSelectionError }
   | { pallet: 'Session'; palletError: PalletSessionError }
+  | { pallet: 'Ismp'; palletError: PalletIsmpError }
+  | { pallet: 'Hyperbridge'; palletError: PalletHyperbridgeError }
+  | { pallet: 'TokenGateway'; palletError: PalletTokenGatewayError }
   | { pallet: 'EmaOracle'; palletError: PalletEmaOracleError }
   | { pallet: 'Broadcast'; palletError: PalletBroadcastError };