@hyperbridge/sdk 1.2.2 → 1.3.0

package/dist/node/index.js

@@ -3,15 +3,15 @@ import { join } from 'path';
 import { TextDecoder as TextDecoder$1, TextEncoder as TextEncoder$1 } from 'util';
 import { createConsola, LogLevels } from 'consola';
 import { flatten, zip, capitalize, maxBy, isNil } from 'lodash-es';
-import { toHex, createPublicClient, http, hexToBytes, bytesToHex, encodeFunctionData, erc20Abi, bytesToBigInt, pad, toBytes, keccak256, encodePacked, encodeAbiParameters, concatHex, maxUint256, parseUnits } from 'viem';
+import { hexToBytes, encodePacked, toHex, keccak256, encodeAbiParameters, bytesToHex, concatHex, createPublicClient, http, encodeFunctionData, erc20Abi, bytesToBigInt, pad, toBytes, maxUint256, parseUnits } from 'viem';
 import mergeRace from '@async-generator/merge-race';
+import { hasWindow, isNode, env } from 'std-env';
+import { Vector, u8, Struct, Tuple, Enum, _void, u64, u32, Option, bool, u128 } from 'scale-ts';
 import { gnosisChiado, gnosis, bscTestnet, bsc, soneium, baseSepolia, base, optimismSepolia, optimism, arbitrumSepolia, arbitrum, mainnet, sepolia } from 'viem/chains';
 import { match } from 'ts-pattern';
 import { WsProvider, ApiPromise } from '@polkadot/api';
 import { RpcWebSocketClient } from 'rpc-websocket-client';
-import { Vector, u8, Struct, Tuple, Enum, _void, u64, u32, Option, bool, u128 } from 'scale-ts';
 import { keccakAsU8a, decodeAddress, xxhashAsU8a } from '@polkadot/util-crypto';
-import { hasWindow, isNode, env } from 'std-env';
 import { GraphQLClient } from 'graphql-request';
 import { u8aToHex } from '@polkadot/util';
 
@@ -230,234 +230,6 @@ var init_node = __esm({
   }
 });
 
-// src/queries.ts
-var POST_REQUEST_STATUS = `
-  query RequestStatusM($hash: String!) {
-  requests(
-    filter: { commitment: { equalTo: $hash } }
-  ) {
-    nodes {
-      commitment
-      timeoutTimestamp
-      source
-      dest
-      to
-      from
-      nonce
-      body
-      statusMetadata {
-        nodes {
-          blockHash
-          blockNumber
-          timestamp
-          chain
-          status
-          transactionHash
-        }
-      }
-    }
-  }
-}
-`;
-var GET_REQUEST_STATUS = `
-query GetRequestDetails($commitment: String!) {
-  getRequests(
-    filter: { commitment: { equalTo: $commitment } }
-  ) {
-    nodes {
-      id
-      source
-      dest
-      from
-      keys
-      nonce
-      height
-      context
-      timeoutTimestamp
-      fee
-      blockNumber
-      blockHash
-      transactionHash
-      blockTimestamp
-      status
-      chain
-      commitment
-      statusMetadata {
-        nodes {
-          status
-          chain
-          timestamp
-          blockNumber
-          blockHash
-          transactionHash
-        }
-      }
-    }
-  }
-}`;
-var STATE_MACHINE_UPDATES_BY_HEIGHT = `
-query StateMachineUpdatesByHeight($statemachineId: String!, $height: Int!, $chain: String!) {
-	stateMachineUpdateEvents(
-		filter: {
-			and: [
-				{ stateMachineId: { equalTo: $statemachineId } }
-				{ height: { greaterThanOrEqualTo: $height } }
-				{ chain: { equalTo: $chain } }
-			]
-		}
-		orderBy: HEIGHT_ASC
-		first: 1
-	) {
-    nodes {
-      height
-      stateMachineId
-      chain
-      blockHash
-      blockNumber
-      transactionHash
-      createdAt
-    }
-  }
-}
-`;
-var STATE_MACHINE_UPDATES_BY_TIMESTAMP = `
-query StateMachineUpdatesByTimestamp($statemachineId: String!, $commitmentTimestamp: BigFloat!, $chain: String!) {
-	stateMachineUpdateEvents(
-		filter: {
-			and: [
-				{ stateMachineId: { equalTo: $statemachineId } }
-				{ commitmentTimestamp: { greaterThanOrEqualTo: $commitmentTimestamp } }
-     			{ chain: { equalTo: $chain } }
-			]
-		}
-		orderBy: COMMITMENT_TIMESTAMP_DESC
-		first: 1
-	) {
-    nodes {
-        height
-        stateMachineId
-        chain
-        blockHash
-        blockNumber
-        transactionHash
-        commitmentTimestamp
-        createdAt
-      }
-    }
-  }
-`;
-var ASSET_TELEPORTED_BY_PARAMS = `
-query AssetTeleportedByParams($from: String!, $to: String!, $dest: String!, $blockNumber: Int!) {
-  assetTeleporteds(
-    filter: {
-      and: [
-        { from: { equalTo: $from } }
-        { to: { equalTo: $to } }
-        { dest: { includes: $dest } }
-        { blockNumber: { greaterThanOrEqualTo: $blockNumber } }
-      ]
-    }
-    orderBy: CREATED_AT_DESC
-    first: 1
-  ) {
-    nodes {
-      id
-      from
-      to
-      amount
-      dest
-      commitment
-      createdAt
-      blockNumber
-    }
-  }
-}
-`;
-var GET_RESPONSE_BY_REQUEST_ID = `
-query GetResponseByRequestId($requestId: String!) {
-  getResponses(filter: {requestId: {equalTo: $requestId}}) {
-    nodes {
-      id
-      commitment
-      responseMessage
-    }
-  }
-}
-`;
-var ORDER_STATUS = `
-query OrderStatus($commitment: String!) {
-  orderPlaceds(
-    filter: { commitment: { equalTo: $commitment } }
-  ) {
-    nodes {
-      id
-      user
-      sourceChain
-      destChain
-      commitment
-      deadline
-      nonce
-      fees
-      inputTokens
-      inputAmounts
-      inputValuesUSD
-      inputUSD
-      outputTokens
-      outputAmounts
-      outputBeneficiaries
-      calldata
-      status
-      createdAt
-      blockNumber
-      blockTimestamp
-      transactionHash
-      statusMetadata {
-        nodes {
-          status
-          chain
-          timestamp
-          blockNumber
-          transactionHash
-          filler
-        }
-      }
-    }
-  }
-}`;
-var TOKEN_GATEWAY_ASSET_TELEPORTED_STATUS = `
-query TokenGatewayAssetTeleportedStatus($commitment: String!) {
-  tokenGatewayAssetTeleporteds(
-    filter: { commitment: { equalTo: $commitment } }
-  ) {
-    nodes {
-      id
-      from
-      to
-      sourceChain
-      destChain
-      commitment
-      amount
-      usdValue
-      assetId
-      redeem
-      status
-      createdAt
-      blockNumber
-      blockTimestamp
-      transactionHash
-      statusMetadata {
-        nodes {
-          status
-          chain
-          timestamp
-          blockNumber
-          transactionHash
-        }
-      }
-    }
-  }
-}`;
-
 // src/types/index.ts
 var RequestStatus = Object.freeze({
   SOURCE: "SOURCE",
@@ -505,16 +277,6 @@ var RequestKind = /* @__PURE__ */ ((RequestKind2) => {
   RequestKind2[RequestKind2["UpdateParams"] = 2] = "UpdateParams";
   return RequestKind2;
 })(RequestKind || {});
-var AbortSignalInternal = class _AbortSignalInternal extends Error {
-  constructor(message) {
-    super();
-    this.name = "AbortSignalInternal";
-    this.message = message;
-  }
-  static isError(error) {
-    return error instanceof _AbortSignalInternal;
-  }
-};
 
 // src/abis/evmHost.ts
 var ABI = [
@@ -3541,1346 +3303,290 @@ var ABI2 = [
   }
 ];
 var handler_default = { ABI: ABI2 };
-var Chains = /* @__PURE__ */ ((Chains2) => {
-  Chains2["BSC_CHAPEL"] = "EVM-97";
-  Chains2["GNOSIS_CHIADO"] = "EVM-10200";
-  Chains2["HYPERBRIDGE_GARGANTUA"] = "KUSAMA-4009";
-  Chains2["SEPOLIA"] = "EVM-11155111";
-  Chains2["MAINNET"] = "EVM-1";
-  Chains2["BSC_MAINNET"] = "EVM-56";
-  return Chains2;
-})(Chains || {});
-var chainIds = {
-  ["EVM-97" /* BSC_CHAPEL */]: 97,
-  ["EVM-10200" /* GNOSIS_CHIADO */]: 10200,
-  ["KUSAMA-4009" /* HYPERBRIDGE_GARGANTUA */]: 4009,
-  ["EVM-11155111" /* SEPOLIA */]: 11155111,
-  ["EVM-1" /* MAINNET */]: 1,
-  ["EVM-56" /* BSC_MAINNET */]: 56
-};
-var viemChains = {
-  "97": bscTestnet,
-  "10200": gnosisChiado,
-  "11155111": sepolia,
-  "1": mainnet,
-  "56": bsc
-};
-var WrappedNativeDecimals = {
-  ["EVM-97" /* BSC_CHAPEL */]: 18,
-  ["EVM-10200" /* GNOSIS_CHIADO */]: 18,
-  ["EVM-11155111" /* SEPOLIA */]: 18,
-  ["EVM-1" /* MAINNET */]: 18,
-  ["EVM-56" /* BSC_MAINNET */]: 18
-};
-var assets = {
-  ["EVM-97" /* BSC_CHAPEL */]: {
-    WETH: "0xae13d989dac2f0debff460ac112a837c89baa7cd".toLowerCase(),
-    DAI: "0x1938165569A5463327fb206bE06d8D9253aa06b7".toLowerCase(),
-    USDC: "0xC625ec7D30A4b1AAEfb1304610CdAcD0d606aC92".toLowerCase(),
-    USDT: "0xc043f483373072f7f27420d6e7d7ad269c018e18".toLowerCase()
-  },
-  ["EVM-10200" /* GNOSIS_CHIADO */]: {
-    WETH: "0x0000000000000000000000000000000000000000".toLowerCase(),
-    DAI: "0x50B1d3c7c073c9caa1Ef207365A2c9C976bD70b9".toLowerCase(),
-    USDC: "0x0000000000000000000000000000000000000000".toLowerCase(),
-    USDT: "0x0000000000000000000000000000000000000000".toLowerCase()
-  },
-  ["EVM-11155111" /* SEPOLIA */]: {
-    WETH: "0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9".toLowerCase(),
-    USDC: "0x0000000000000000000000000000000000000000".toLowerCase(),
-    USDT: "0x0000000000000000000000000000000000000000".toLowerCase(),
-    DAI: "0x0000000000000000000000000000000000000000".toLowerCase()
-  },
-  ["EVM-1" /* MAINNET */]: {
-    WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2".toLowerCase(),
-    DAI: "0x6B175474E89094C44Da98b954EedeAC495271d0F".toLowerCase(),
-    USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48".toLowerCase(),
-    USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7".toLowerCase()
-  },
-  ["EVM-56" /* BSC_MAINNET */]: {
-    WETH: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c".toLowerCase(),
-    DAI: "0x1AF3F329e8BE154074D8769D1FFa4eE058B1DBc3".toLowerCase(),
-    USDC: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d".toLowerCase(),
-    USDT: "0x55d398326f99059fF775485246999027B3197955".toLowerCase()
+function getPeakPosByHeight(height) {
+  return (1n << BigInt(height + 1)) - 2n;
+}
+function leftPeakHeightPos(mmrSize) {
+  let height = 1;
+  let prevPos = 0n;
+  let pos = getPeakPosByHeight(height);
+  while (pos < mmrSize) {
+    height += 1;
+    prevPos = pos;
+    pos = getPeakPosByHeight(height);
   }
-};
-var addresses = {
-  IntentGateway: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0xb6C27F4beF379d0b5e2fe3Bb36c248D6B71f91A6",
-    ["EVM-10200" /* GNOSIS_CHIADO */]: "0xb6C27F4beF379d0b5e2fe3Bb36c248D6B71f91A6",
-    ["EVM-11155111" /* SEPOLIA */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-1" /* MAINNET */]: "0xd54165e45926720b062C192a5bacEC64d5bB08DA",
-    ["EVM-56" /* BSC_MAINNET */]: "0xd54165e45926720b062C192a5bacEC64d5bB08DA"
-  },
-  Host: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0x8Aa0Dea6D675d785A882967Bf38183f6117C09b7",
-    ["EVM-10200" /* GNOSIS_CHIADO */]: "0x58a41b89f4871725e5d898d98ef4bf917601c5eb",
-    ["EVM-11155111" /* SEPOLIA */]: "0x2EdB74C269948b60ec1000040E104cef0eABaae8",
-    ["EVM-1" /* MAINNET */]: "0x792A6236AF69787C40cF76b69B4c8c7B28c4cA20",
-    ["EVM-56" /* BSC_MAINNET */]: "0x24B5d421Ec373FcA57325dd2F0C074009Af021F7"
-  },
-  UniswapRouter02: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0x9639379819420704457B07A0C33B678D9E0F8Df0",
-    ["EVM-10200" /* GNOSIS_CHIADO */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-11155111" /* SEPOLIA */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-1" /* MAINNET */]: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
-    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
-  },
-  UniswapV2Factory: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0x12e036669DA18F4A2777853d6e2136b32AceEC86",
-    ["EVM-10200" /* GNOSIS_CHIADO */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-11155111" /* SEPOLIA */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-1" /* MAINNET */]: "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
-    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
-  },
-  BatchExecutor: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0x4CC58B5D8FBf838d062E4b21F75C327835B5F0ef",
-    ["EVM-1" /* MAINNET */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
-  },
-  UniversalRouter: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0xcc6d5ece3d4a57245bf5a2f64f3ed9179b81f714",
-    ["EVM-1" /* MAINNET */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
-  },
-  UniswapV3Router: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-1" /* MAINNET */]: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
-    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
-  },
-  UniswapV3Factory: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-1" /* MAINNET */]: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
-    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
-  },
-  UniswapV3Quoter: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-1" /* MAINNET */]: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
-    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
-  },
-  UniswapV4PoolManager: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-1" /* MAINNET */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
-  },
-  UniswapV4Quoter: {
-    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-1" /* MAINNET */]: "0x52f0e24d1c21c8a0cb1e5a5dd6198556bd9e1203",
-    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
-  },
-  Calldispatcher: {
-    ["EVM-11155111" /* SEPOLIA */]: "0xC7f13b6D03A0A7F3239d38897503E90553ABe155"
+  return [height - 1, prevPos];
+}
+function getRightPeak(initialHeight, initialPos, mmrSize) {
+  let height = initialHeight;
+  let pos = initialPos;
+  pos += siblingOffset(height);
+  while (pos > mmrSize - 1n) {
+    if (height === 0) {
+      return null;
+    }
+    pos -= parentOffset(height - 1);
+    height -= 1;
   }
-};
-var createRpcUrls = (env2) => ({
-  ["EVM-97" /* BSC_CHAPEL */]: env2.BSC_CHAPEL || "https://bnb-testnet.api.onfinality.io/public",
-  ["EVM-10200" /* GNOSIS_CHIADO */]: env2.GNOSIS_CHIADO || "https://gnosis-chiado-rpc.publicnode.com",
-  ["KUSAMA-4009" /* HYPERBRIDGE_GARGANTUA */]: env2.HYPERBRIDGE_GARGANTUA || "",
-  ["EVM-11155111" /* SEPOLIA */]: env2.SEPOLIA || "https://1rpc.io/sepolia",
-  ["EVM-1" /* MAINNET */]: env2.ETH_MAINNET || "https://eth-mainnet.g.alchemy.com/v2/demo",
-  ["EVM-56" /* BSC_MAINNET */]: env2.BSC_MAINNET || "https://binance.llamarpc.com"
-});
-var consensusStateIds = {
-  ["EVM-97" /* BSC_CHAPEL */]: "BSC0",
-  ["EVM-10200" /* GNOSIS_CHIADO */]: "GNO0",
-  ["KUSAMA-4009" /* HYPERBRIDGE_GARGANTUA */]: "PAS0",
-  ["EVM-11155111" /* SEPOLIA */]: "ETH0",
-  ["EVM-1" /* MAINNET */]: "ETH0",
-  ["EVM-56" /* BSC_MAINNET */]: "BSC0"
-};
-
-// src/configs/ChainConfigService.ts
-var ChainConfigService = class {
-  rpcUrls;
-  constructor(env2 = process.env) {
-    this.rpcUrls = createRpcUrls(env2);
+  return [height, pos];
+}
+function getPeaks(mmrSize) {
+  const positions = [];
+  let [height, pos] = leftPeakHeightPos(mmrSize);
+  positions.push(pos);
+  while (height > 0) {
+    const peak = getRightPeak(height, pos, mmrSize);
+    if (!peak) break;
+    [height, pos] = peak;
+    positions.push(pos);
   }
-  getChainConfig(chain) {
-    return {
-      chainId: chainIds[chain],
-      rpcUrl: this.rpcUrls[chain],
-      intentGatewayAddress: addresses.IntentGateway[chain]
-    };
+  return positions;
+}
+function allOnes(num) {
+  if (num === 0n) return false;
+  return num.toString(2).split("").every((bit) => bit === "1");
+}
+function jumpLeft(pos) {
+  const bitLength = pos.toString(2).length;
+  const mostSignificantBits = 1n << BigInt(bitLength - 1);
+  return pos - (mostSignificantBits - 1n);
+}
+function posHeightInTree(initialPos) {
+  let pos = initialPos + 1n;
+  while (!allOnes(pos)) {
+    pos = jumpLeft(pos);
   }
-  getIntentGatewayAddress(chain) {
-    return addresses.IntentGateway[chain];
+  return pos.toString(2).length - 1;
+}
+function parentOffset(height) {
+  return 2n << BigInt(height);
+}
+function siblingOffset(height) {
+  return (2n << BigInt(height)) - 1n;
+}
+function takeWhileVec(v, p) {
+  const index = v.findIndex((item) => !p(item));
+  if (index === -1) {
+    const result = [...v];
+    v.length = 0;
+    return result;
   }
-  getHostAddress(chain) {
-    return addresses.Host[chain];
+  return v.splice(0, index);
+}
+function mmrPositionToKIndex(initialLeaves, mmrSize) {
+  const leaves = [...initialLeaves];
+  const peaks = getPeaks(mmrSize);
+  const leavesWithKIndices = [];
+  for (const peak of peaks) {
+    const peakLeaves = takeWhileVec(leaves, (pos) => pos <= peak);
+    if (peakLeaves.length > 0) {
+      for (const pos of peakLeaves) {
+        const height = posHeightInTree(peak);
+        let index = 0n;
+        let parentPos = peak;
+        for (let h = height; h >= 1; h--) {
+          const leftChild = parentPos - parentOffset(h - 1);
+          const rightChild = leftChild + siblingOffset(h - 1);
+          index *= 2n;
+          if (leftChild >= pos) {
+            parentPos = leftChild;
+          } else {
+            parentPos = rightChild;
+            index += 1n;
+          }
+        }
+        leavesWithKIndices.push([pos, index]);
+      }
+    }
   }
-  getWrappedNativeAssetWithDecimals(chain) {
-    return {
-      asset: assets[chain].WETH,
-      decimals: WrappedNativeDecimals[chain]
-    };
+  return leavesWithKIndices;
+}
+function calculateMMRSize(numberOfLeaves) {
+  const numberOfPeaks = numberOfLeaves.toString(2).split("1").length - 1;
+  return 2n * numberOfLeaves - BigInt(numberOfPeaks);
+}
+async function generateRootWithProof(postRequest, treeSize) {
+  const { generate_root_with_proof: generate_root_with_proof2 } = await load_ckb_mmr();
+  const { commitment: hash, encodePacked: encodePacked2 } = postRequestCommitment(postRequest);
+  const result = JSON.parse(generate_root_with_proof2(hexToBytes(encodePacked2), treeSize));
+  const { root, proof, mmr_size, leaf_positions, keccak_hash_calldata } = result;
+  if (keccak_hash_calldata !== hash) {
+    console.log("keccak_hash", keccak_hash_calldata);
+    console.log("hash", hash);
+    throw new Error("Abi keccak hash mismatch");
   }
-  getDaiAsset(chain) {
-    return assets[chain].DAI;
-  }
-  getUsdtAsset(chain) {
-    return assets[chain].USDT;
-  }
-  getUsdcAsset(chain) {
-    return assets[chain].USDC;
-  }
-  getChainId(chain) {
-    return chainIds[chain];
-  }
-  getConsensusStateId(chain) {
-    return toHex(consensusStateIds[chain]);
-  }
-  getHyperbridgeChainId() {
-    return chainIds["KUSAMA-4009" /* HYPERBRIDGE_GARGANTUA */];
-  }
-  getRpcUrl(chain) {
-    return this.rpcUrls[chain];
-  }
-  getUniswapRouterV2Address(chain) {
-    return addresses.UniswapRouter02[chain];
-  }
-  getUniswapV2FactoryAddress(chain) {
-    return addresses.UniswapV2Factory[chain];
-  }
-  getBatchExecutorAddress(chain) {
-    return addresses.BatchExecutor[chain];
-  }
-  getUniversalRouterAddress(chain) {
-    return addresses.UniversalRouter[chain];
-  }
-  getUniswapV3RouterAddress(chain) {
-    return addresses.UniswapV3Router[chain];
-  }
-  getUniswapV3FactoryAddress(chain) {
-    return addresses.UniswapV3Factory[chain];
-  }
-  getUniswapV3QuoterAddress(chain) {
-    return addresses.UniswapV3Quoter[chain];
-  }
-  getUniswapV4PoolManagerAddress(chain) {
-    return addresses.UniswapV4PoolManager[chain];
-  }
-  getUniswapV4QuoterAddress(chain) {
-    return addresses.UniswapV4Quoter[chain];
-  }
-};
-
-// src/chains/evm.ts
-var chains = {
-  [mainnet.id]: mainnet,
-  [arbitrum.id]: arbitrum,
-  [arbitrumSepolia.id]: arbitrumSepolia,
-  [optimism.id]: optimism,
-  [optimismSepolia.id]: optimismSepolia,
-  [base.id]: base,
-  [baseSepolia.id]: baseSepolia,
-  [soneium.id]: soneium,
-  [bsc.id]: bsc,
-  [bscTestnet.id]: bscTestnet,
-  [gnosis.id]: gnosis,
-  [gnosisChiado.id]: gnosisChiado
-};
-var DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
-var EvmChain = class {
-  constructor(params) {
-    this.params = params;
-    this.publicClient = createPublicClient({
-      // @ts-ignore
-      chain: chains[params.chainId],
-      transport: http(params.url)
-    });
-    this.chainConfigService = new ChainConfigService();
-  }
-  publicClient;
-  chainConfigService;
-  // Expose minimal getters for external helpers/classes
-  get client() {
-    return this.publicClient;
-  }
-  get host() {
-    return this.params.host;
+  const [[, kIndex]] = mmrPositionToKIndex(leaf_positions, BigInt(mmr_size));
+  return {
+    root,
+    proof,
+    index: treeSize - 1n,
+    kIndex,
+    treeSize,
+    mmrSize: mmr_size
+  };
+}
+async function load_ckb_mmr() {
+  if (hasWindow) {
+    const wasm2 = await Promise.resolve().then(() => (init_node(), node_exports));
+    await wasm2.default();
+    return wasm2;
   }
-  get config() {
-    return this.chainConfigService;
+  if (isNode) {
+    const wasm2 = await Promise.resolve().then(() => (init_node(), node_exports));
+    return wasm2;
   }
+  throw new Error(`SDK not setup for ${env}`);
+}
+async function __test() {
+  const { generate_root_with_proof: generate_root_with_proof2 } = await load_ckb_mmr();
+  return generate_root_with_proof2(new Uint8Array(), 120n);
+}
+var H256 = Vector(u8, 32);
+var EvmStateProof = Struct({
   /**
-   * Derives the key for the request receipt.
-   * @param {HexString} commitment - The commitment to derive the key from.
-   * @returns {HexString} The derived key.
+   * Proof of the contract state.
    */
-  requestReceiptKey(commitment) {
-    return deriveMapKey(hexToBytes(commitment), REQUEST_RECEIPTS_SLOT);
-  }
+  contractProof: Vector(Vector(u8)),
   /**
-   * Queries the request receipt.
-   * @param {HexString} commitment - The commitment to query.
-   * @returns {Promise<HexString | undefined>} The relayer address responsible for delivering the request.
+   * Proof of the storage state.
    */
-  async queryRequestReceipt(commitment) {
-    const relayer = await this.publicClient.readContract({
-      address: this.params.host,
-      abi: evmHost_default.ABI,
-      functionName: "requestReceipts",
-      args: [commitment]
-    });
-    return relayer === DEFAULT_ADDRESS ? void 0 : relayer;
-  }
+  storageProof: Vector(Tuple(Vector(u8), Vector(Vector(u8))))
+});
+var SubstrateHashing = Enum({
+  /* For chains that use keccak as their hashing algo */
+  Keccak: _void,
+  /* For chains that use blake2b as their hashing algo */
+  Blake2: _void
+});
+var SubstrateStateMachineProof = Struct({
   /**
-   * Queries the proof of the commitments.
-   * @param {IMessage} message - The message to query.
-   * @param {string} counterparty - The counterparty address.
-   * @param {bigint} [at] - The block number to query at.
-   * @returns {Promise<HexString>} The proof.
+   * The hasher used to hash the state machine state.
    */
-  async queryProof(message, counterparty, at) {
-    const commitmentKeys = "Requests" in message ? message.Requests.map((key) => requestCommitmentKey(key)) : message.Responses.map((key) => responseCommitmentKey(key));
-    const config = {
-      address: this.params.host,
-      storageKeys: commitmentKeys
-    };
-    if (!at) {
-      config.blockTag = "latest";
-    } else {
-      config.blockNumber = at;
-    }
-    const proof = await this.publicClient.getProof(config);
-    const flattenedProof = Array.from(new Set(flatten(proof.storageProof.map((item) => item.proof))));
-    const encoded = EvmStateProof.enc({
-      contractProof: proof.accountProof.map((item) => Array.from(hexToBytes(item))),
-      storageProof: [
-        [Array.from(hexToBytes(this.params.host)), flattenedProof.map((item) => Array.from(hexToBytes(item)))]
-      ]
-    });
-    return toHex(encoded);
-  }
+  hasher: SubstrateHashing,
   /**
-   * Query and return the encoded storage proof for the provided keys at the given height.
-   * @param {bigint} at - The block height at which to query the storage proof.
-   * @param {HexString[]} keys - The keys for which to query the storage proof.
-   * @returns {Promise<HexString>} The encoded storage proof.
+   * Proof of the state machine state.
    */
-  async queryStateProof(at, keys) {
-    const config = {
-      address: this.params.host,
-      storageKeys: keys
-    };
-    if (!at) {
-      config.blockTag = "latest";
-    } else {
-      config.blockNumber = at;
-    }
-    const proof = await this.publicClient.getProof(config);
-    const flattenedProof = Array.from(new Set(flatten(proof.storageProof.map((item) => item.proof))));
-    const encoded = EvmStateProof.enc({
-      contractProof: proof.accountProof.map((item) => Array.from(hexToBytes(item))),
-      storageProof: [
-        [Array.from(hexToBytes(this.params.host)), flattenedProof.map((item) => Array.from(hexToBytes(item)))]
-      ]
-    });
-    return toHex(encoded);
-  }
-  /**
-   * Returns the current timestamp of the chain.
-   * @returns {Promise<bigint>} The current timestamp.
+  storageProof: Vector(Vector(u8))
+});
+var SubstrateStateProof = Enum({
+  /*
+   * Uses overlay root for verification
    */
-  async timestamp() {
-    const data = await this.publicClient.readContract({
-      address: this.params.host,
-      abi: evmHost_default.ABI,
-      functionName: "timestamp"
-    });
-    return BigInt(data);
-  }
-  /**
-   * Get the latest state machine height for a given state machine ID.
-   * @param {StateMachineIdParams} stateMachineId - The state machine ID.
-   * @returns {Promise<bigint>} The latest state machine height.
+  OverlayProof: SubstrateStateMachineProof,
+  /*
+   * Uses state root for verification
    */
-  async latestStateMachineHeight(stateMachineId) {
-    if (!this.publicClient) throw new Error("API not initialized");
-    const id = stateMachineId.stateId.Polkadot || stateMachineId.stateId.Kusama;
-    if (!id)
-      throw new Error(
-        "Expected Polakdot or Kusama State machine id when reading latest state machine height on evm"
-      );
-    const data = await this.publicClient.readContract({
-      address: this.params.host,
-      abi: evmHost_default.ABI,
-      functionName: "latestStateMachineHeight",
-      args: [BigInt(id)]
-    });
-    return data;
-  }
-  /**
-   * Get the state machine update time for a given state machine height.
-   * @param {StateMachineHeight} stateMachineHeight - The state machine height.
-   * @returns {Promise<bigint>} The statemachine update time in seconds.
+  StateProof: SubstrateStateMachineProof
+});
+var BasicProof = Vector(Vector(u8));
+var LeafIndexAndPos = Struct({
+  /*
+   * Leaf index
    */
-  async stateMachineUpdateTime(stateMachineHeight) {
-    if (!this.publicClient) throw new Error("API not initialized");
-    const id = stateMachineHeight.id.stateId.Polkadot || stateMachineHeight.id.stateId.Kusama;
-    if (!id) throw new Error("Expected Polkadot or Kusama State machine id when reading state machine update time");
-    const data = await this.publicClient.readContract({
-      address: this.params.host,
-      abi: evmHost_default.ABI,
-      functionName: "stateMachineCommitmentUpdateTime",
-      args: [{ stateMachineId: BigInt(id), height: stateMachineHeight.height }]
-    });
-    return data;
-  }
-  /**
-   * Get the challenge period for a given state machine id.
-   * @param {StateMachineIdParams} stateMachineId - The state machine ID.
-   * @returns {Promise<bigint>} The challenge period in seconds.
+  leafIndex: u64,
+  /*
+   * Leaf position in the MMR
    */
-  async challengePeriod(stateMachineId) {
-    if (!this.publicClient) throw new Error("API not initialized");
-    const id = stateMachineId.stateId.Polkadot || stateMachineId.stateId.Kusama;
-    if (!id)
-      throw new Error(
-        "Expected Polkadot or Kusama State machine id when reading latest state machine height on evm"
-      );
-    const data = await this.publicClient.readContract({
-      address: this.params.host,
-      abi: evmHost_default.ABI,
-      functionName: "challengePeriod"
-    });
-    return data;
-  }
-  /**
-   * Encodes an ISMP message for the EVM chain.
-   * @param {IIsmpMessage} message The ISMP message to encode.
-   * @returns {HexString} The encoded calldata.
+  pos: u64
+});
+var MmrProof = Struct({
+  /*
+   * Proof of the leaf index and position.
    */
-  encode(message) {
-    const encoded = match(message).with({ kind: "PostRequest" }, (request) => {
-      const mmrProof = MmrProof.dec(request.proof.proof);
-      const requests = zip(request.requests, mmrProof.leafIndexAndPos).map(([req, leafIndexAndPos]) => {
-        if (!req || !leafIndexAndPos) return;
-        const [[, kIndex]] = mmrPositionToKIndex(
-          [leafIndexAndPos?.pos],
-          calculateMMRSize(mmrProof.leafCount)
-        );
-        return {
-          request: {
-            source: toHex(req.source),
-            dest: toHex(req.dest),
-            to: req.to,
-            from: req.from,
-            nonce: req.nonce,
-            timeoutTimestamp: req.timeoutTimestamp,
-            body: req.body
-          },
-          index: leafIndexAndPos?.leafIndex,
-          kIndex
-        };
-      }).filter((item) => !!item);
-      const proof = {
-        height: {
-          stateMachineId: BigInt(Number.parseInt(request.proof.stateMachine.split("-")[1])),
-          height: request.proof.height
-        },
-        multiproof: mmrProof.items.map((item) => bytesToHex(new Uint8Array(item))),
-        leafCount: mmrProof.leafCount
-      };
-      const encoded2 = encodeFunctionData({
-        abi: handler_default.ABI,
-        functionName: "handlePostRequests",
-        args: [
-          this.params.host,
-          {
-            proof,
-            requests
-          }
-        ]
-      });
-      return encoded2;
-    }).with({ kind: "TimeoutPostRequest" }, (timeout) => {
-      const proof = SubstrateStateProof.dec(timeout.proof.proof).value.storageProof.map(
-        (item) => toHex(new Uint8Array(item))
-      );
-      const encoded2 = encodeFunctionData({
-        abi: handler_default.ABI,
-        functionName: "handlePostRequestTimeouts",
-        args: [
-          this.params.host,
-          {
-            height: {
-              stateMachineId: BigInt(Number.parseInt(timeout.proof.stateMachine.split("-")[1])),
-              height: timeout.proof.height
-            },
-            timeouts: timeout.requests.map((req) => ({
-              source: toHex(req.source),
-              dest: toHex(req.dest),
-              to: req.to,
-              from: req.from,
-              nonce: req.nonce,
-              timeoutTimestamp: req.timeoutTimestamp,
-              body: req.body
-            })),
-            proof
-          }
-        ]
-      });
-      return encoded2;
-    }).with({ kind: "GetResponse" }, (request) => {
-      const mmrProof = MmrProof.dec(request.proof.proof);
-      const responses = zip(request.responses, mmrProof.leafIndexAndPos).map(([req, leafIndexAndPos]) => {
-        if (!req || !leafIndexAndPos) return;
-        const [[, kIndex]] = mmrPositionToKIndex(
-          [leafIndexAndPos?.pos],
-          calculateMMRSize(mmrProof.leafCount)
-        );
-        return {
-          response: {
-            request: {
-              source: toHex(req.get.source),
-              dest: toHex(req.get.dest),
-              from: req.get.from,
-              nonce: req.get.nonce,
-              timeoutTimestamp: req.get.timeoutTimestamp,
-              keys: req.get.keys,
-              context: req.get.context,
-              height: req.get.height
-            },
-            values: req.values
-          },
-          index: leafIndexAndPos?.leafIndex,
-          kIndex
-        };
-      }).filter((item) => !!item);
-      const proof = {
-        height: {
-          stateMachineId: BigInt(Number.parseInt(request.proof.stateMachine.split("-")[1])),
-          height: request.proof.height
-        },
-        multiproof: mmrProof.items.map((item) => bytesToHex(new Uint8Array(item))),
-        leafCount: mmrProof.leafCount
-      };
-      const encoded2 = encodeFunctionData({
-        abi: handler_default.ABI,
-        functionName: "handleGetResponses",
-        args: [
-          this.params.host,
-          {
-            proof,
-            responses
-          }
-        ]
-      });
-      return encoded2;
-    }).exhaustive();
-    return encoded;
-  }
-  /**
-   * Calculates the fee required to send a post request to the destination chain.
-   * The fee is calculated based on the per-byte fee for the destination chain
-   * multiplied by the size of the request body.
-   *
-   * @param request - The post request to calculate the fee for
-   * @returns The total fee in wei required to send the post request
+  leafIndexAndPos: Vector(LeafIndexAndPos),
+  /*
+   * Proof of the leaf data.
    */
-  async quote(request) {
-    const perByteFee = await this.publicClient.readContract({
-      address: this.params.host,
-      abi: evmHost_default.ABI,
-      functionName: "perByteFee",
-      args: [toHex(request.dest)]
-    });
-    const bodyByteLength = Math.floor((request.body.length - 2) / 2);
-    const length = bodyByteLength < 32 ? 32 : bodyByteLength;
-    return perByteFee * BigInt(length);
-  }
-  /**
-   * Estimates the gas required for a post request execution on this chain.
-   * This function generates mock proofs for the post request, creates a state override
-   * with the necessary overlay root, and estimates the gas cost for executing the
-   * handlePostRequests transaction on the handler contract.
-   *
-   * @param request - The post request to estimate gas for
-   * @param paraId - The ID of the parachain (Hyperbridge) that will process the request
-   * @returns The estimated gas amount in gas units
+  leafCount: u64,
+  /*
+   * Proof elements (hashes of siblings of inner nodes on the path to the leaf).
    */
-  async estimateGas(request) {
-    const hostParams = await this.publicClient.readContract({
-      address: this.params.host,
-      abi: evmHost_default.ABI,
-      functionName: "hostParams"
-    });
-    const { root, proof, index, kIndex, treeSize } = await generateRootWithProof(request, 2n ** 10n);
-    const latestStateMachineHeight = 6291991n;
-    const paraId = 4009n;
-    const overlayRootSlot = getStateCommitmentFieldSlot(
-      paraId,
-      // Hyperbridge chain id
-      latestStateMachineHeight,
-      // Hyperbridge chain height
-      1
-      // For overlayRoot
-    );
-    const postParams = {
-      height: {
-        stateMachineId: BigInt(paraId),
-        height: latestStateMachineHeight
-      },
-      multiproof: proof,
-      leafCount: treeSize
-    };
-    const gas = await this.publicClient.estimateContractGas({
-      address: hostParams.handler,
-      abi: handler_default.ABI,
-      functionName: "handlePostRequests",
-      args: [
-        this.params.host,
-        {
-          proof: postParams,
-          requests: [
-            {
-              request: {
-                ...request,
-                source: toHex(request.source),
-                dest: toHex(request.dest)
-              },
-              index,
-              kIndex
-            }
-          ]
-        }
-      ],
-      stateOverride: [
-        {
-          address: this.params.host,
-          stateDiff: [
-            {
-              slot: overlayRootSlot,
-              value: root
-            }
-          ]
-        }
-      ]
-    });
-    return gas;
-  }
-  /**
-   * Gets the fee token address and decimals for the chain.
-   * This function gets the fee token address and decimals for the chain.
-   *
-   * @returns The fee token address and decimals
+  items: Vector(H256)
+});
+var ConsensusStateId = Vector(u8, 4);
+var ConsensusMessage = Struct({
+  /*
+   * Consensus message data.
    */
-  async getFeeTokenWithDecimals() {
-    const hostParams = await this.publicClient.readContract({
-      abi: evmHost_default.ABI,
-      address: this.params.host,
-      functionName: "hostParams"
-    });
-    const feeTokenAddress = hostParams.feeToken;
-    const feeTokenDecimals = await this.publicClient.readContract({
-      address: feeTokenAddress,
-      abi: erc20Abi,
-      functionName: "decimals"
-    });
-    return { address: feeTokenAddress, decimals: feeTokenDecimals };
-  }
-  /**
-   * Gets the nonce of the host.
-   * This function gets the nonce of the host.
-   *
-   * @returns The nonce of the host
+  consensusProof: Vector(u8),
+  /*
+   * Consensus state Id
    */
-  async getHostNonce() {
-    const nonce = await this.publicClient.readContract({
-      abi: evmHost_default.ABI,
-      address: this.params.host,
-      functionName: "nonce"
-    });
-    return nonce;
-  }
-};
-var REQUEST_COMMITMENTS_SLOT = 0n;
-var RESPONSE_COMMITMENTS_SLOT = 1n;
-var REQUEST_RECEIPTS_SLOT = 2n;
-var RESPONSE_RECEIPTS_SLOT = 3n;
-var STATE_COMMITMENTS_SLOT = 5n;
-function requestCommitmentKey(key) {
-  const keyBytes = hexToBytes(key);
-  const slot = REQUEST_COMMITMENTS_SLOT;
-  const mappedKey = deriveMapKey(keyBytes, slot);
-  const number = bytesToBigInt(hexToBytes(mappedKey)) + 1n;
-  return pad(`0x${number.toString(16)}`, { size: 32 });
-}
-function responseCommitmentKey(key) {
-  const keyBytes = hexToBytes(key);
-  const slot = RESPONSE_COMMITMENTS_SLOT;
-  const mappedKey = deriveMapKey(keyBytes, slot);
-  const number = bytesToBigInt(hexToBytes(mappedKey)) + 1n;
-  return pad(`0x${number.toString(16)}`, { size: 32 });
-}
-function deriveMapKey(key, slot) {
-  const slotBytes = pad(`0x${slot.toString(16)}`, { size: 32 });
-  const combined = new Uint8Array([...key, ...toBytes(slotBytes)]);
-  return keccak256(combined);
-}
-function getStateCommitmentFieldSlot(stateMachineId, height, field) {
-  const baseSlot = getStateCommitmentSlot(stateMachineId, height);
-  const slotNumber = bytesToBigInt(toBytes(baseSlot)) + BigInt(field);
-  return pad(`0x${slotNumber.toString(16)}`, { size: 32 });
-}
-function getStateCommitmentSlot(stateMachineId, height) {
-  const firstLevelSlot = deriveFirstLevelSlot(stateMachineId, STATE_COMMITMENTS_SLOT);
-  return deriveSecondLevelSlot(height, firstLevelSlot);
-}
-function deriveFirstLevelSlot(key, slot) {
-  const keyHex = pad(`0x${key.toString(16)}`, { size: 32 });
-  const keyBytes = toBytes(keyHex);
-  const slotBytes = toBytes(pad(`0x${slot.toString(16)}`, { size: 32 }));
-  const combined = new Uint8Array([...keyBytes, ...slotBytes]);
-  return keccak256(combined);
-}
-function deriveSecondLevelSlot(key, firstLevelSlot) {
-  const keyHex = pad(`0x${key.toString(16)}`, { size: 32 });
-  const keyBytes = toBytes(keyHex);
-  const slotBytes = toBytes(firstLevelSlot);
-  const combined = new Uint8Array([...keyBytes, ...slotBytes]);
-  return keccak256(combined);
-}
-var SubstrateChain = class {
-  constructor(params) {
-    this.params = params;
-  }
+  consensusStateId: ConsensusStateId,
   /*
-   * api: The Polkadot API instance for the Substrate chain.
+   * Public key of the sender
    */
-  api;
+  signer: Vector(u8)
+});
+var FraudProofMessage = Struct({
   /*
-   * connect: Connects to the Substrate chain using the provided WebSocket URL.
+   * The first valid consensus proof
    */
-  async connect() {
-    const wsProvider = new WsProvider(this.params.ws);
-    const typesBundle = this.params.hasher === "Keccak" ? {
-      spec: {
-        nexus: {
-          hasher: keccakAsU8a
-        },
-        gargantua: {
-          hasher: keccakAsU8a
-        }
-      }
-    } : {};
-    this.api = await ApiPromise.create({
-      provider: wsProvider,
-      typesBundle
-    });
-  }
-  /**
-   * Disconnects the Substrate chain connection.
+  proof1: Vector(u8),
+  /*
+   * The second valid consensus proof
    */
-  async disconnect() {
-    if (this.api) {
-      await this.api.disconnect();
-      this.api = void 0;
-    }
-  }
-  /**
-   * Returns the storage key for a request receipt in the child trie
-   * The request commitment is the key
-   * @param key - The H256 hash key (as a 0x-prefixed hex string)
-   * @returns The storage key as a hex string
+  proof2: Vector(u8),
+  /*
+   * Consensus state Id
    */
-  requestReceiptKey(key) {
-    const prefix = new TextEncoder().encode("RequestReceipts");
-    const keyBytes = hexToBytes(key);
-    return bytesToHex(new Uint8Array([...prefix, ...keyBytes]));
-  }
-  /**
-   * Returns the storage key for a request commitment in the child trie
-   * The request commitment is the key
-   * @param key - The H256 hash key (as a 0x-prefixed hex string)
-   * @returns The storage key as a hex string
+  consensusStateId: ConsensusStateId
+});
+var StateMachine = Enum({
+  /*
+   * Evm state machines
    */
-  requestCommitmentKey(key) {
-    const prefix = new TextEncoder().encode("RequestCommitments");
-    const keyBytes = hexToBytes(key);
-    return bytesToHex(new Uint8Array([...prefix, ...keyBytes]));
-  }
-  /**
-   * Queries a request commitment from the ISMP child trie storage.
-   * @param {HexString} commitment - The commitment hash to look up.
-   * @returns {Promise<HexString | undefined>} The commitment data if found, undefined otherwise.
+  Evm: u32,
+  /*
+   * Polkadot parachains
    */
-  async queryRequestCommitment(commitment) {
-    const prefix = toHex(":child_storage:default:ISMP");
-    const key = this.requestCommitmentKey(commitment);
-    const rpc = new RpcWebSocketClient();
-    await rpc.connect(this.params.ws);
-    const item = await rpc.call("childstate_getStorage", [prefix, key]);
-    return item;
-  }
-  /**
-   * Queries the request receipt.
-   * @param {HexString} commitment - The commitment to query.
-   * @returns {Promise<HexString | undefined>} The relayer address responsible for delivering the request.
+  Polkadot: u32,
+  /*
+   * Kusama parachains
    */
-  async queryRequestReceipt(commitment) {
-    const prefix = toHex(":child_storage:default:ISMP");
-    const key = this.requestReceiptKey(commitment);
-    const rpc = new RpcWebSocketClient();
-    await rpc.connect(this.params.ws);
-    const item = await rpc.call("childstate_getStorage", [prefix, key]);
-    return item;
-  }
-  /**
-   * Returns the current timestamp of the chain.
-   * @returns {Promise<bigint>} The current timestamp.
+  Kusama: u32,
+  /*
+   * Substrate-based standalone chain
    */
-  async timestamp() {
-    if (!this.api) throw new Error("API not initialized");
-    const now = await this.api.query.timestamp.now();
-    return BigInt(now.toJSON()) / BigInt(1e3);
-  }
-  /**
-   * Queries the proof of the commitments.
-   * @param {IMessage} message - The message to query.
-   * @param {string} counterparty - The counterparty address.
-   * @param {bigint} [at] - The block number to query at.
-   * @returns {Promise<HexString>} The proof.
+  Substrate: ConsensusStateId,
+  /*
+   * Tendermint chains
    */
-  async queryProof(message, counterparty, at) {
-    const rpc = new RpcWebSocketClient();
-    await rpc.connect(this.params.ws);
-    if (isEvmChain(counterparty)) {
-      const proof = await rpc.call("mmr_queryProof", [Number(at), message]);
-      return toHex(proof.proof);
-    }
-    if (isSubstrateChain(counterparty)) {
-      const childTrieKeys = "Requests" in message ? message.Requests.map(requestCommitmentStorageKey) : message.Responses.map(responseCommitmentStorageKey);
-      const proof = await rpc.call("ismp_queryChildTrieProof", [Number(at), childTrieKeys]);
-      const basicProof = BasicProof.dec(toHex(proof.proof));
-      const encoded = SubstrateStateProof.enc({
-        tag: "OverlayProof",
-        value: {
-          hasher: {
-            tag: this.params.hasher,
-            value: void 0
-          },
-          storageProof: basicProof
-        }
-      });
-      return toHex(encoded);
-    }
-    throw new Error(`Unsupported chain type for counterparty: ${counterparty}`);
-  }
-  /**
-   * Submit an unsigned ISMP transaction to the chain. Resolves when the transaction is finalized.
-   * @param message - The message to be submitted.
-   * @returns A promise that resolves to an object containing the transaction hash, block hash, and block number.
+  Tendermint: ConsensusStateId
+});
+var StateMachineId = Struct({
+  /*
+   * The state machine id
    */
-  async submitUnsigned(message) {
-    if (!this.api) throw new Error("API not initialized");
-    const { api } = this;
-    const args = hexToBytes(this.encode(message)).slice(2);
-    const tx = api.tx.ismp.handleUnsigned(args);
-    return new Promise((resolve, reject) => {
-      let unsub = () => {
-      };
-      tx.send(async ({ isInBlock, isFinalized, isError, dispatchError, txHash, status }) => {
-        if (isFinalized || isInBlock) {
-          unsub();
-          const blockHash = isInBlock ? status.asInBlock.toHex() : status.asFinalized.toHex();
-          const header = await api.rpc.chain.getHeader(blockHash);
-          const apiAt = await api.at(blockHash);
-          const timestamp = await apiAt.query.timestamp.now();
-          resolve({
-            transactionHash: txHash.toHex(),
-            blockHash,
-            blockNumber: header.number.toNumber(),
-            timestamp: Number(timestamp.toJSON()) / 1e3
-          });
-        } else if (isError) {
-          unsub();
-          console.error("Unsigned transaction failed: ", dispatchError);
-          reject(dispatchError);
-        }
-      }).then((unsubscribe) => {
-        unsub = unsubscribe;
-      }).catch(reject);
-    });
-  }
-  /**
-   * Query the state proof for a given set of keys at a specific block height.
-   * @param at The block height to query the state proof at.
-   * @param keys The keys to query the state proof for.
-   * @returns The state proof as a hexadecimal string.
+  id: StateMachine,
+  /*
+   * The consensus state id
    */
-  async queryStateProof(at, keys) {
-    const rpc = new RpcWebSocketClient();
-    await rpc.connect(this.params.ws);
-    const encodedKeys = keys.map((key) => Array.from(hexToBytes(key)));
-    const proof = await rpc.call("ismp_queryChildTrieProof", [Number(at), encodedKeys]);
-    const basicProof = BasicProof.dec(toHex(proof.proof));
-    const encoded = SubstrateStateProof.enc({
-      tag: "OverlayProof",
-      value: {
-        hasher: {
-          tag: this.params.hasher,
-          value: void 0
-        },
-        storageProof: basicProof
-      }
-    });
-    return toHex(encoded);
-  }
-  /**
-   * Get the latest state machine height for a given state machine ID.
-   * @param {StateMachineIdParams} stateMachineId - The state machine ID.
-   * @returns {Promise<bigint>} The latest state machine height.
+  consensusStateId: ConsensusStateId
+});
+var StateMachineHeight = Struct({
+  /*
+   * The state machine id
    */
-  async latestStateMachineHeight(stateMachineId) {
-    if (!this.api) throw new Error("API not initialized");
-    const latestHeight = await this.api.query.ismp.latestStateMachineHeight(stateMachineId);
-    return BigInt(latestHeight.toString());
-  }
-  /**
-   * Get the state machine update time for a given state machine height.
-   * @param {StateMachineHeight} stateMachineheight - The state machine height.
-   * @returns {Promise<bigint>} The statemachine update time in seconds.
+  id: StateMachineId,
+  /*
+   * The height of the state machine
    */
-  async stateMachineUpdateTime(stateMachineHeight) {
-    if (!this.api) throw new Error("API not initialized");
-    const updateTime = await this.api.query.ismp.stateMachineUpdateTime(stateMachineHeight);
-    return BigInt(updateTime.toString());
-  }
-  /**
-   * Get the challenge period for a given state machine id.
-   * @param {StateMachineIdParams} stateMachineId - The state machine ID.
-   * @returns {Promise<bigint>} The challenge period in seconds.
+  height: u64
+});
+var Proof = Struct({
+  /*
+   * The height of the state machine
    */
-  async challengePeriod(stateMachineId) {
-    if (!this.api) throw new Error("API not initialized");
-    const challengePeriod = await this.api.query.ismp.challengePeriod(stateMachineId);
-    return BigInt(challengePeriod.toString());
-  }
-  /**
-   * Encode an ISMP calldata for a substrate chain.
-   * @param message The ISMP message to encode.
-   * @returns The encoded message as a hexadecimal string.
+  height: StateMachineHeight,
+  /*
+   * The proof
    */
-  encode(message) {
-    const palletIndex = this.getPalletIndex("Ismp");
-    const args = encodeISMPMessage(message);
-    const call = Vector(u8, 2).enc([palletIndex, 0]);
-    return toHex(new Uint8Array([...call, ...args]));
-  }
-  /**
-   * Returns the index of a pallet by its name, by looking up the pallets in the runtime metadata.
-   * @param {string} name - The name of the pallet.
-   * @returns {number} The index of the pallet.
-   */
-  getPalletIndex(name) {
-    if (!this.api) throw new Error("API not initialized");
-    const pallets = this.api.runtimeMetadata.asLatest.pallets.entries();
-    for (const p of pallets) {
-      if (p[1].name.toString() === name) {
-        const index = p[1].index.toNumber();
-        return index;
-      }
-    }
-    throw new Error(`${name} not found in runtime`);
-  }
-};
-function requestCommitmentStorageKey(key) {
-  const prefix = new TextEncoder().encode("RequestCommitments");
-  const keyBytes = hexToBytes(key);
-  return Array.from(new Uint8Array([...prefix, ...keyBytes]));
-}
-function responseCommitmentStorageKey(key) {
-  const prefix = new TextEncoder().encode("ResponseCommitments");
-  const keyBytes = hexToBytes(key);
-  return Array.from(new Uint8Array([...prefix, ...keyBytes]));
-}
-function convertStateMachineIdToEnum(id) {
-  let [tag, value] = id.split("-");
-  tag = capitalize(tag);
-  if (["Evm", "Polkadot", "Kusama"].includes(tag)) {
-    value = Number.parseInt(value);
-  } else {
-    value = Array.from(toBytes(value));
-  }
-  return { tag, value };
-}
-function convertIPostRequestToCodec(request) {
-  return {
-    tag: "Post",
-    value: {
-      source: convertStateMachineIdToEnum(request.source),
-      dest: convertStateMachineIdToEnum(request.dest),
-      from: Array.from(hexToBytes(request.from)),
-      to: Array.from(hexToBytes(request.to)),
-      nonce: request.nonce,
-      body: Array.from(hexToBytes(request.body)),
-      timeoutTimestamp: request.timeoutTimestamp
-    }
-  };
-}
-function encodeISMPMessage(message) {
-  try {
-    return match(message).with({ kind: "PostRequest" }, (message2) => {
-      return Vector(Message).enc([
-        {
-          tag: "RequestMessage",
-          value: {
-            requests: message2.requests.map(
-              (post_request) => convertIPostRequestToCodec(post_request).value
-            ),
-            proof: {
-              height: {
-                height: message2.proof.height,
-                id: {
-                  consensusStateId: Array.from(toBytes(message2.proof.consensusStateId)),
-                  id: convertStateMachineIdToEnum(message2.proof.stateMachine)
-                }
-              },
-              proof: Array.from(hexToBytes(message2.proof.proof))
-            },
-            signer: Array.from(hexToBytes(message2.signer))
-          }
-        }
-      ]);
-    }).with({ kind: "GetResponse" }, (message2) => {
-      throw new Error("GetResponse is not yet supported on Substrate chains");
-    }).with({ kind: "TimeoutPostRequest" }, (message2) => {
-      return Vector(Message).enc([
-        {
-          tag: "TimeoutMessage",
-          value: {
-            tag: "Post",
-            value: {
-              requests: message2.requests.map((r) => convertIPostRequestToCodec(r)),
-              proof: {
-                height: {
-                  height: message2.proof.height,
-                  id: {
-                    consensusStateId: Array.from(toBytes(message2.proof.consensusStateId)),
-                    id: convertStateMachineIdToEnum(message2.proof.stateMachine)
-                  }
-                },
-                proof: Array.from(hexToBytes(message2.proof.proof))
-              }
-            }
-          }
-        }
-      ]);
-    }).exhaustive();
-  } catch (error) {
-    throw new Error("Failed to encode ISMP message", { cause: error });
-  }
-}
-
-// src/chain.ts
-async function getChain(chainConfig) {
-  if (isEvmChain(chainConfig.stateMachineId)) {
-    const config = chainConfig;
-    const chainId = Number.parseInt(chainConfig.stateMachineId.split("-")[1]);
-    const evmChain = new EvmChain({
-      chainId,
-      url: config.rpcUrl,
-      host: config.host
-    });
-    return evmChain;
-  }
-  if (isSubstrateChain(chainConfig.stateMachineId)) {
-    const config = chainConfig;
-    const substrateChain = new SubstrateChain({
-      ws: config.wsUrl,
-      hasher: config.hasher
-    });
-    await substrateChain.connect();
-    return substrateChain;
-  }
-  throw new Error(`Unsupported chain: ${chainConfig.stateMachineId}`);
-}
-function getPeakPosByHeight(height) {
-  return (1n << BigInt(height + 1)) - 2n;
-}
-function leftPeakHeightPos(mmrSize) {
-  let height = 1;
-  let prevPos = 0n;
-  let pos = getPeakPosByHeight(height);
-  while (pos < mmrSize) {
-    height += 1;
-    prevPos = pos;
-    pos = getPeakPosByHeight(height);
-  }
-  return [height - 1, prevPos];
-}
-function getRightPeak(initialHeight, initialPos, mmrSize) {
-  let height = initialHeight;
-  let pos = initialPos;
-  pos += siblingOffset(height);
-  while (pos > mmrSize - 1n) {
-    if (height === 0) {
-      return null;
-    }
-    pos -= parentOffset(height - 1);
-    height -= 1;
-  }
-  return [height, pos];
-}
-function getPeaks(mmrSize) {
-  const positions = [];
-  let [height, pos] = leftPeakHeightPos(mmrSize);
-  positions.push(pos);
-  while (height > 0) {
-    const peak = getRightPeak(height, pos, mmrSize);
-    if (!peak) break;
-    [height, pos] = peak;
-    positions.push(pos);
-  }
-  return positions;
-}
-function allOnes(num) {
-  if (num === 0n) return false;
-  return num.toString(2).split("").every((bit) => bit === "1");
-}
-function jumpLeft(pos) {
-  const bitLength = pos.toString(2).length;
-  const mostSignificantBits = 1n << BigInt(bitLength - 1);
-  return pos - (mostSignificantBits - 1n);
-}
-function posHeightInTree(initialPos) {
-  let pos = initialPos + 1n;
-  while (!allOnes(pos)) {
-    pos = jumpLeft(pos);
-  }
-  return pos.toString(2).length - 1;
-}
-function parentOffset(height) {
-  return 2n << BigInt(height);
-}
-function siblingOffset(height) {
-  return (2n << BigInt(height)) - 1n;
-}
-function takeWhileVec(v, p) {
-  const index = v.findIndex((item) => !p(item));
-  if (index === -1) {
-    const result = [...v];
-    v.length = 0;
-    return result;
-  }
-  return v.splice(0, index);
-}
-function mmrPositionToKIndex(initialLeaves, mmrSize) {
-  const leaves = [...initialLeaves];
-  const peaks = getPeaks(mmrSize);
-  const leavesWithKIndices = [];
-  for (const peak of peaks) {
-    const peakLeaves = takeWhileVec(leaves, (pos) => pos <= peak);
-    if (peakLeaves.length > 0) {
-      for (const pos of peakLeaves) {
-        const height = posHeightInTree(peak);
-        let index = 0n;
-        let parentPos = peak;
-        for (let h = height; h >= 1; h--) {
-          const leftChild = parentPos - parentOffset(h - 1);
-          const rightChild = leftChild + siblingOffset(h - 1);
-          index *= 2n;
-          if (leftChild >= pos) {
-            parentPos = leftChild;
-          } else {
-            parentPos = rightChild;
-            index += 1n;
-          }
-        }
-        leavesWithKIndices.push([pos, index]);
-      }
-    }
-  }
-  return leavesWithKIndices;
-}
-function calculateMMRSize(numberOfLeaves) {
-  const numberOfPeaks = numberOfLeaves.toString(2).split("1").length - 1;
-  return 2n * numberOfLeaves - BigInt(numberOfPeaks);
-}
-async function generateRootWithProof(postRequest, treeSize) {
-  const { generate_root_with_proof: generate_root_with_proof2 } = await load_ckb_mmr();
-  const { commitment: hash, encodePacked: encodePacked3 } = postRequestCommitment(postRequest);
-  const result = JSON.parse(generate_root_with_proof2(hexToBytes(encodePacked3), treeSize));
-  const { root, proof, mmr_size, leaf_positions, keccak_hash_calldata } = result;
-  if (keccak_hash_calldata !== hash) {
-    console.log("keccak_hash", keccak_hash_calldata);
-    console.log("hash", hash);
-    throw new Error("Abi keccak hash mismatch");
-  }
-  const [[, kIndex]] = mmrPositionToKIndex(leaf_positions, BigInt(mmr_size));
-  return {
-    root,
-    proof,
-    index: treeSize - 1n,
-    kIndex,
-    treeSize,
-    mmrSize: mmr_size
-  };
-}
-async function load_ckb_mmr() {
-  if (hasWindow) {
-    const wasm2 = await Promise.resolve().then(() => (init_node(), node_exports));
-    await wasm2.default();
-    return wasm2;
-  }
-  if (isNode) {
-    const wasm2 = await Promise.resolve().then(() => (init_node(), node_exports));
-    return wasm2;
-  }
-  throw new Error(`SDK not setup for ${env}`);
-}
-async function __test() {
-  const { generate_root_with_proof: generate_root_with_proof2 } = await load_ckb_mmr();
-  return generate_root_with_proof2(new Uint8Array(), 120n);
-}
-var H256 = Vector(u8, 32);
-var EvmStateProof = Struct({
-  /**
-   * Proof of the contract state.
-   */
-  contractProof: Vector(Vector(u8)),
-  /**
-   * Proof of the storage state.
-   */
-  storageProof: Vector(Tuple(Vector(u8), Vector(Vector(u8))))
-});
-var SubstrateHashing = Enum({
-  /* For chains that use keccak as their hashing algo */
-  Keccak: _void,
-  /* For chains that use blake2b as their hashing algo */
-  Blake2: _void
-});
-var SubstrateStateMachineProof = Struct({
-  /**
-   * The hasher used to hash the state machine state.
-   */
-  hasher: SubstrateHashing,
-  /**
-   * Proof of the state machine state.
-   */
-  storageProof: Vector(Vector(u8))
-});
-var SubstrateStateProof = Enum({
-  /*
-   * Uses overlay root for verification
-   */
-  OverlayProof: SubstrateStateMachineProof,
-  /*
-   * Uses state root for verification
-   */
-  StateProof: SubstrateStateMachineProof
-});
-var BasicProof = Vector(Vector(u8));
-var LeafIndexAndPos = Struct({
-  /*
-   * Leaf index
-   */
-  leafIndex: u64,
-  /*
-   * Leaf position in the MMR
-   */
-  pos: u64
-});
-var MmrProof = Struct({
-  /*
-   * Proof of the leaf index and position.
-   */
-  leafIndexAndPos: Vector(LeafIndexAndPos),
-  /*
-   * Proof of the leaf data.
-   */
-  leafCount: u64,
-  /*
-   * Proof elements (hashes of siblings of inner nodes on the path to the leaf).
-   */
-  items: Vector(H256)
-});
-var ConsensusStateId = Vector(u8, 4);
-var ConsensusMessage = Struct({
-  /*
-   * Consensus message data.
-   */
-  consensusProof: Vector(u8),
-  /*
-   * Consensus state Id
-   */
-  consensusStateId: ConsensusStateId,
-  /*
-   * Public key of the sender
-   */
-  signer: Vector(u8)
-});
-var FraudProofMessage = Struct({
-  /*
-   * The first valid consensus proof
-   */
-  proof1: Vector(u8),
-  /*
-   * The second valid consensus proof
-   */
-  proof2: Vector(u8),
-  /*
-   * Consensus state Id
-   */
-  consensusStateId: ConsensusStateId
-});
-var StateMachine = Enum({
-  /*
-   * Evm state machines
-   */
-  Evm: u32,
-  /*
-   * Polkadot parachains
-   */
-  Polkadot: u32,
-  /*
-   * Kusama parachains
-   */
-  Kusama: u32,
-  /*
-   * Substrate-based standalone chain
-   */
-  Substrate: ConsensusStateId,
-  /*
-   * Tendermint chains
-   */
-  Tendermint: ConsensusStateId
-});
-var StateMachineId = Struct({
-  /*
-   * The state machine id
-   */
-  id: StateMachine,
-  /*
-   * The consensus state id
-   */
-  consensusStateId: ConsensusStateId
-});
-var StateMachineHeight = Struct({
-  /*
-   * The state machine id
-   */
-  id: StateMachineId,
-  /*
-   * The height of the state machine
-   */
-  height: u64
-});
-var Proof = Struct({
-  /*
-   * The height of the state machine
-   */
-  height: StateMachineHeight,
-  /*
-   * The proof
-   */
-  proof: Vector(u8)
-});
-var PostRequest = Struct({
-  /*
-   * The source state machine of this request.
+  proof: Vector(u8)
+});
+var PostRequest = Struct({
+  /*
+   * The source state machine of this request.
    */
   source: StateMachine,
   /*
@@ -5052,474 +3758,1781 @@ var TimeoutMessage = Enum({
   /*
    * A non memership proof for POST responses
    */
-  PostResponse: Struct({
-    /*
-     * Timed out responses
-     */
-    responses: Vector(Response),
-    /*
-     * Membership batch proof for these responses
-     */
-    proof: Proof
-  }),
+  PostResponse: Struct({
+    /*
+     * Timed out responses
+     */
+    responses: Vector(Response),
+    /*
+     * Membership batch proof for these responses
+     */
+    proof: Proof
+  }),
+  /*
+   * There are no proofs for Get timeouts
+   */
+  Get: Struct({
+    /*
+     * Timed out requests
+     */
+    requests: Vector(Request)
+  })
+});
+var Message = Enum({
+  /*
+   * A consensus update message
+   */
+  ConsensusMessage,
+  /*
+   * A fraud proof message
+   */
+  FraudProofMessage,
+  /*
+   * A request message
+   */
+  RequestMessage,
+  /*
+   * A response message
+   */
+  ResponseMessage,
+  /*
+   * A request timeout message
+   */
+  TimeoutMessage
+});
+
+// src/utils.ts
+var DEFAULT_POLL_INTERVAL = 5e3;
+var ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
+var MOCK_ADDRESS = "0x1234567890123456789012345678901234567890";
+var DUMMY_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms || DEFAULT_POLL_INTERVAL));
+}
+async function waitForChallengePeriod(chain, stateMachineHeight) {
+  const challengePeriod = await chain.challengePeriod(stateMachineHeight.id);
+  if (challengePeriod === BigInt(0)) return;
+  const updateTime = await chain.stateMachineUpdateTime(stateMachineHeight);
+  let currentTimestamp = await chain.timestamp();
+  let timeElapsed = currentTimestamp - updateTime;
+  if (timeElapsed > challengePeriod) return;
+  await sleep(Number(challengePeriod) * 1e3);
+  while (timeElapsed <= challengePeriod) {
+    const remainingTime = challengePeriod - timeElapsed;
+    await sleep(Number(remainingTime) * 1e3);
+    currentTimestamp = await chain.timestamp();
+    timeElapsed = currentTimestamp - updateTime;
+  }
+}
+function isEvmChain(stateMachineId) {
+  return stateMachineId.startsWith("EVM");
+}
+function isSubstrateChain(stateMachineId) {
+  return stateMachineId.startsWith("POLKADOT") || stateMachineId.startsWith("KUSAMA") || stateMachineId.startsWith("SUBSTRATE");
+}
+function parseStateMachineId(stateMachineId) {
+  const [type, value] = stateMachineId.split("-");
+  if (!type || !value) {
+    throw new Error(
+      `Invalid state machine ID format: ${stateMachineId}. Expected format like "EVM-97" or "SUBSTRATE-cere"`
+    );
+  }
+  const stateId = {};
+  switch (type.toUpperCase()) {
+    case "EVM": {
+      const evmChainId = Number.parseInt(value, 10);
+      if (Number.isNaN(evmChainId)) {
+        throw new Error(`Invalid EVM chain ID: ${value}. Expected a number.`);
+      }
+      stateId.Evm = evmChainId;
+      break;
+    }
+    case "SUBSTRATE": {
+      const bytes = Buffer.from(value, "utf8");
+      stateId.Substrate = `0x${bytes.toString("hex")}`;
+      break;
+    }
+    case "POLKADOT": {
+      const polkadotChainId = Number.parseInt(value, 10);
+      if (Number.isNaN(polkadotChainId)) {
+        throw new Error(`Invalid Polkadot chain ID: ${value}. Expected a number.`);
+      }
+      stateId.Polkadot = polkadotChainId;
+      break;
+    }
+    case "KUSAMA": {
+      const kusamaChainId = Number.parseInt(value, 10);
+      if (Number.isNaN(kusamaChainId)) {
+        throw new Error(`Invalid Kusama chain ID: ${value}. Expected a number.`);
+      }
+      stateId.Kusama = kusamaChainId;
+      break;
+    }
+    default:
+      throw new Error(`Unsupported chain type: ${type}. Expected one of: EVM, SUBSTRATE, POLKADOT, KUSAMA.`);
+  }
+  return { stateId };
+}
+function postRequestCommitment(post) {
+  const data = encodePacked(
+    ["bytes", "bytes", "uint64", "uint64", "bytes", "bytes", "bytes"],
+    [toHex(post.source), toHex(post.dest), post.nonce, post.timeoutTimestamp, post.from, post.to, post.body]
+  );
+  return {
+    commitment: keccak256(data),
+    encodePacked: data
+  };
+}
+function orderCommitment(order) {
+  const encodedOrder = encodeAbiParameters(
+    [
+      {
+        name: "order",
+        type: "tuple",
+        components: [
+          { name: "user", type: "bytes32" },
+          { name: "sourceChain", type: "bytes" },
+          { name: "destChain", type: "bytes" },
+          { name: "deadline", type: "uint256" },
+          { name: "nonce", type: "uint256" },
+          { name: "fees", type: "uint256" },
+          {
+            name: "outputs",
+            type: "tuple[]",
+            components: [
+              { name: "token", type: "bytes32" },
+              { name: "amount", type: "uint256" },
+              { name: "beneficiary", type: "bytes32" }
+            ]
+          },
+          {
+            name: "inputs",
+            type: "tuple[]",
+            components: [
+              { name: "token", type: "bytes32" },
+              { name: "amount", type: "uint256" }
+            ]
+          },
+          { name: "callData", type: "bytes" }
+        ]
+      }
+    ],
+    [
+      {
+        user: order.user,
+        sourceChain: order.sourceChain.startsWith("0x") ? order.sourceChain : toHex(order.sourceChain),
+        destChain: order.destChain.startsWith("0x") ? order.destChain : toHex(order.destChain),
+        deadline: order.deadline,
+        nonce: order.nonce,
+        fees: order.fees,
+        outputs: order.outputs,
+        inputs: order.inputs,
+        callData: order.callData
+      }
+    ]
+  );
+  return keccak256(encodedOrder);
+}
+function bytes32ToBytes20(bytes32Address) {
+  if (bytes32Address === ADDRESS_ZERO) {
+    return ADDRESS_ZERO;
+  }
+  const bytes = hexToBytes(bytes32Address);
+  const addressBytes = bytes.slice(12);
+  return bytesToHex(addressBytes);
+}
+function bytes20ToBytes32(bytes20Address) {
+  return `0x${bytes20Address.slice(2).padStart(64, "0")}`;
+}
+function hexToString(hex) {
+  const hexWithoutPrefix = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(hexWithoutPrefix.length / 2);
+  for (let i = 0; i < hexWithoutPrefix.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(hexWithoutPrefix.slice(i, i + 2), 16);
+  }
+  return new TextDecoder().decode(bytes);
+}
+var DEFAULT_LOGGER = createConsola({
+  level: LogLevels.silent
+});
+async function retryPromise(operation, retryConfig) {
+  const { logger = DEFAULT_LOGGER, logMessage = "Retry operation failed" } = retryConfig;
+  let lastError;
+  for (let i = 0; i < retryConfig.maxRetries; i++) {
+    try {
+      return await operation();
+    } catch (error) {
+      logger.trace(`Retrying(${i}) > ${logMessage}`);
+      lastError = error;
+      await new Promise((resolve) => setTimeout(resolve, retryConfig.backoffMs * 2 ** i));
+    }
+  }
+  throw lastError;
+}
+function getRequestCommitment(get) {
+  const keysEncoding = "0x".concat(get.keys.map((key) => key.slice(2)).join(""));
+  return keccak256(
+    encodePacked(
+      ["bytes", "bytes", "uint64", "uint64", "uint64", "bytes", "bytes", "bytes"],
+      [
+        toHex(get.source),
+        toHex(get.dest),
+        get.nonce,
+        get.height,
+        get.timeoutTimestamp,
+        get.from,
+        keysEncoding,
+        get.context
+      ]
+    )
+  );
+}
+var REQUEST_STATUS_WEIGHTS = {
+  [RequestStatus.SOURCE]: 0,
+  [RequestStatus.SOURCE_FINALIZED]: 1,
+  [RequestStatus.HYPERBRIDGE_DELIVERED]: 2,
+  [RequestStatus.HYPERBRIDGE_FINALIZED]: 3,
+  [RequestStatus.DESTINATION]: 4,
+  [RequestStatus.HYPERBRIDGE_TIMED_OUT]: 5,
+  [RequestStatus.TIMED_OUT]: 6
+};
+var TIMEOUT_STATUS_WEIGHTS = {
+  [TimeoutStatus.PENDING_TIMEOUT]: 1,
+  [TimeoutStatus.DESTINATION_FINALIZED_TIMEOUT]: 2,
+  [TimeoutStatus.HYPERBRIDGE_TIMED_OUT]: 3,
+  [TimeoutStatus.HYPERBRIDGE_FINALIZED_TIMEOUT]: 4,
+  [TimeoutStatus.TIMED_OUT]: 5
+};
+var COMBINED_STATUS_WEIGHTS = {
+  [RequestStatus.SOURCE]: 0,
+  [RequestStatus.SOURCE_FINALIZED]: 1,
+  [RequestStatus.HYPERBRIDGE_DELIVERED]: 2,
+  [RequestStatus.HYPERBRIDGE_FINALIZED]: 3,
+  [RequestStatus.DESTINATION]: 4,
+  [TimeoutStatus.PENDING_TIMEOUT]: 5,
+  [TimeoutStatus.DESTINATION_FINALIZED_TIMEOUT]: 6,
+  [TimeoutStatus.HYPERBRIDGE_TIMED_OUT]: 7,
+  [TimeoutStatus.HYPERBRIDGE_FINALIZED_TIMEOUT]: 8,
+  [TimeoutStatus.TIMED_OUT]: 9
+};
+async function estimateGasForPost(params) {
+  const hostParams = await params.sourceClient.readContract({
+    address: params.hostAddress,
+    abi: evmHost_default.ABI,
+    functionName: "hostParams"
+  });
+  const { root, proof, index, kIndex, treeSize } = await generateRootWithProof(params.postRequest, 2n ** 10n);
+  const latestStateMachineHeight = params.hostLatestStateMachineHeight;
+  const overlayRootSlot = getStateCommitmentFieldSlot(
+    BigInt(4009n),
+    // Hyperbridge chain id
+    latestStateMachineHeight,
+    // Hyperbridge chain height
+    1
+    // For overlayRoot
+  );
+  const postParams = {
+    height: {
+      stateMachineId: BigInt(4009n),
+      height: latestStateMachineHeight
+    },
+    multiproof: proof,
+    leafCount: treeSize
+  };
+  const call_data = [
+    params.hostAddress,
+    {
+      proof: postParams,
+      requests: [
+        {
+          request: {
+            ...params.postRequest,
+            source: toHex(params.postRequest.source),
+            dest: toHex(params.postRequest.dest)
+          },
+          index,
+          kIndex
+        }
+      ]
+    }
+  ];
+  const gas_fee = await params.sourceClient.estimateContractGas({
+    address: hostParams.handler,
+    abi: handler_default.ABI,
+    functionName: "handlePostRequests",
+    args: call_data,
+    stateOverride: [
+      {
+        address: params.hostAddress,
+        stateDiff: [
+          {
+            slot: overlayRootSlot,
+            value: root
+          }
+        ]
+      }
+    ]
+  });
+  return { gas_fee, call_data };
+}
+function constructRedeemEscrowRequestBody(order, beneficiary) {
+  const commitment = order.id;
+  const inputs = order.inputs;
+  const requestKind = encodePacked(["uint8"], [0 /* RedeemEscrow */]);
+  const requestBody = {
+    commitment,
+    beneficiary: bytes20ToBytes32(beneficiary),
+    tokens: inputs
+  };
+  const encodedRequestBody = encodeAbiParameters(
+    [
+      {
+        name: "requestBody",
+        type: "tuple",
+        components: [
+          { name: "commitment", type: "bytes32" },
+          { name: "beneficiary", type: "bytes32" },
+          {
+            name: "tokens",
+            type: "tuple[]",
+            components: [
+              { name: "token", type: "bytes32" },
+              { name: "amount", type: "uint256" }
+            ]
+          }
+        ]
+      }
+    ],
+    [requestBody]
+  );
+  return concatHex([requestKind, encodedRequestBody]);
+}
+var dateStringtoTimestamp = (date) => {
+  if (!date.endsWith("Z")) {
+    date = `${date}Z`;
+  }
+  return new Date(date).getTime();
+};
+function mapTestnetToMainnet(identifier) {
+  identifier = identifier.toLowerCase();
+  switch (identifier) {
+    case "bnb":
+      return "wbnb";
+    case "eth":
+      return "weth";
+    case "tbnb":
+      return "wbnb";
+    case "0xc043f483373072f7f27420d6e7d7ad269c018e18".toLowerCase():
+      return "dai";
+    case "0xae13d989dac2f0debff460ac112a837c89baa7cd".toLowerCase():
+      return "wbnb";
+    case "0x1938165569A5463327fb206bE06d8D9253aa06b7".toLowerCase():
+      return "dai";
+    case "0xC625ec7D30A4b1AAEfb1304610CdAcD0d606aC92".toLowerCase():
+      return "dai";
+    case "0x50B1d3c7c073c9caa1Ef207365A2c9C976bD70b9".toLowerCase():
+      return "dai";
+    case "0xa801da100bf16d07f668f4a49e1f71fc54d05177".toLowerCase():
+      return "dai";
+    default:
+      return identifier;
+  }
+}
+async function fetchTokenUsdPrice(identifier) {
+  try {
+    const coinGeckoPrice = await fetchFromCoinGecko(identifier);
+    return coinGeckoPrice;
+  } catch (error) {
+    try {
+      const defillamaPrice = await fetchFromDefillama(identifier);
+      return defillamaPrice;
+    } catch (fallbackError) {
+      console.log(
+        `Both APIs failed for ${identifier}. CoinGecko: ${error}, Defillama: ${fallbackError}. Returning 1`
+      );
+      return 1;
+    }
+  }
+}
+async function fetchFromCoinGecko(identifier) {
+  const mappedIdentifier = mapTestnetToMainnet(identifier);
+  const url = mappedIdentifier.startsWith("0x") ? `https://api.coingecko.com/api/v3/simple/token_price/ethereum?contract_addresses=${mappedIdentifier}&vs_currencies=usd` : `https://api.coingecko.com/api/v3/simple/price?ids=${mappedIdentifier}&vs_currencies=usd`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`CoinGecko API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  const key = mappedIdentifier.toLowerCase();
+  if (!data[key]?.usd) {
+    throw new Error(`Price not found for token: ${mappedIdentifier}`);
+  }
+  return data[key].usd;
+}
+async function fetchFromDefillama(identifier) {
+  const mappedIdentifier = mapTestnetToMainnet(identifier);
+  const coinId = mappedIdentifier.startsWith("0x") ? `ethereum:${mappedIdentifier}` : `coingecko:${mappedIdentifier}`;
+  const url = `https://coins.llama.fi/prices/current/${coinId}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Defillama API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  const price = data.coins?.[coinId]?.price;
+  if (!price && price !== 0) {
+    throw new Error(`Price not found for token: ${mappedIdentifier}`);
+  }
+  return price;
+}
+var ERC20Method = /* @__PURE__ */ ((ERC20Method2) => {
+  ERC20Method2["BALANCE_OF"] = "0x70a08231";
+  ERC20Method2["ALLOWANCE"] = "0xdd62ed3e";
+  return ERC20Method2;
+})(ERC20Method || {});
+async function getStorageSlot(client, contractAddress, data) {
+  const traceCallClient = client.extend((client2) => ({
+    async traceCall(args) {
+      return client2.request({
+        // @ts-ignore
+        method: "debug_traceCall",
+        // @ts-ignore
+        params: [args, "latest", {}]
+      });
+    }
+  }));
+  const response = await traceCallClient.traceCall({
+    to: contractAddress,
+    data
+  });
+  const methodSignature = data.slice(0, 10);
+  const logs = response.structLogs;
+  for (let i = logs.length - 1; i >= 0; i--) {
+    const log = logs[i];
+    if (log.op === "SLOAD" && log.stack?.length >= 3) {
+      const sigHash = log.stack[0];
+      const slotHex = log.stack[log.stack.length - 1];
+      if (sigHash === methodSignature && slotHex.length === 66) {
+        return slotHex;
+      }
+    }
+  }
+  throw new Error(`Storage slot not found for data: ${methodSignature}`);
+}
+function adjustFeeDecimals(feeInFeeToken, fromDecimals, toDecimals) {
+  if (fromDecimals === toDecimals) return feeInFeeToken;
+  if (fromDecimals < toDecimals) {
+    const scaleFactor = BigInt(10 ** (toDecimals - fromDecimals));
+    return feeInFeeToken * scaleFactor;
+  } else {
+    const scaleFactor = BigInt(10 ** (fromDecimals - toDecimals));
+    return (feeInFeeToken + scaleFactor - 1n) / scaleFactor;
+  }
+}
+
+// src/utils/exceptions.ts
+var AbortSignalInternal = class _AbortSignalInternal extends Error {
+  constructor(message) {
+    super();
+    this.name = "Hyperbridge/SDK/AbortSignalInternal";
+    this.message = message;
+  }
+  static isError(error) {
+    return error instanceof _AbortSignalInternal;
+  }
+};
+var ExpectedError = class _ExpectedError extends Error {
+  constructor(message) {
+    super();
+    this.name = "Hyperbridge/SDK/ExpectedError";
+    this.message = message;
+  }
+  static isError(error) {
+    return error instanceof _ExpectedError;
+  }
+};
+var Chains = /* @__PURE__ */ ((Chains2) => {
+  Chains2["BSC_CHAPEL"] = "EVM-97";
+  Chains2["GNOSIS_CHIADO"] = "EVM-10200";
+  Chains2["HYPERBRIDGE_GARGANTUA"] = "KUSAMA-4009";
+  Chains2["SEPOLIA"] = "EVM-11155111";
+  Chains2["MAINNET"] = "EVM-1";
+  Chains2["BSC_MAINNET"] = "EVM-56";
+  return Chains2;
+})(Chains || {});
+var chainIds = {
+  ["EVM-97" /* BSC_CHAPEL */]: 97,
+  ["EVM-10200" /* GNOSIS_CHIADO */]: 10200,
+  ["KUSAMA-4009" /* HYPERBRIDGE_GARGANTUA */]: 4009,
+  ["EVM-11155111" /* SEPOLIA */]: 11155111,
+  ["EVM-1" /* MAINNET */]: 1,
+  ["EVM-56" /* BSC_MAINNET */]: 56
+};
+var viemChains = {
+  "97": bscTestnet,
+  "10200": gnosisChiado,
+  "11155111": sepolia,
+  "1": mainnet,
+  "56": bsc
+};
+var WrappedNativeDecimals = {
+  ["EVM-97" /* BSC_CHAPEL */]: 18,
+  ["EVM-10200" /* GNOSIS_CHIADO */]: 18,
+  ["EVM-11155111" /* SEPOLIA */]: 18,
+  ["EVM-1" /* MAINNET */]: 18,
+  ["EVM-56" /* BSC_MAINNET */]: 18
+};
+var assets = {
+  ["EVM-97" /* BSC_CHAPEL */]: {
+    WETH: "0xae13d989dac2f0debff460ac112a837c89baa7cd".toLowerCase(),
+    DAI: "0x1938165569A5463327fb206bE06d8D9253aa06b7".toLowerCase(),
+    USDC: "0xC625ec7D30A4b1AAEfb1304610CdAcD0d606aC92".toLowerCase(),
+    USDT: "0xc043f483373072f7f27420d6e7d7ad269c018e18".toLowerCase()
+  },
+  ["EVM-10200" /* GNOSIS_CHIADO */]: {
+    WETH: "0x0000000000000000000000000000000000000000".toLowerCase(),
+    DAI: "0x50B1d3c7c073c9caa1Ef207365A2c9C976bD70b9".toLowerCase(),
+    USDC: "0x0000000000000000000000000000000000000000".toLowerCase(),
+    USDT: "0x0000000000000000000000000000000000000000".toLowerCase()
+  },
+  ["EVM-11155111" /* SEPOLIA */]: {
+    WETH: "0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9".toLowerCase(),
+    USDC: "0x0000000000000000000000000000000000000000".toLowerCase(),
+    USDT: "0x0000000000000000000000000000000000000000".toLowerCase(),
+    DAI: "0x0000000000000000000000000000000000000000".toLowerCase()
+  },
+  ["EVM-1" /* MAINNET */]: {
+    WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2".toLowerCase(),
+    DAI: "0x6B175474E89094C44Da98b954EedeAC495271d0F".toLowerCase(),
+    USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48".toLowerCase(),
+    USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7".toLowerCase()
+  },
+  ["EVM-56" /* BSC_MAINNET */]: {
+    WETH: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c".toLowerCase(),
+    DAI: "0x1AF3F329e8BE154074D8769D1FFa4eE058B1DBc3".toLowerCase(),
+    USDC: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d".toLowerCase(),
+    USDT: "0x55d398326f99059fF775485246999027B3197955".toLowerCase()
+  }
+};
+var addresses = {
+  IntentGateway: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0xb6C27F4beF379d0b5e2fe3Bb36c248D6B71f91A6",
+    ["EVM-10200" /* GNOSIS_CHIADO */]: "0xb6C27F4beF379d0b5e2fe3Bb36c248D6B71f91A6",
+    ["EVM-11155111" /* SEPOLIA */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-1" /* MAINNET */]: "0xd54165e45926720b062C192a5bacEC64d5bB08DA",
+    ["EVM-56" /* BSC_MAINNET */]: "0xd54165e45926720b062C192a5bacEC64d5bB08DA"
+  },
+  Host: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x8Aa0Dea6D675d785A882967Bf38183f6117C09b7",
+    ["EVM-10200" /* GNOSIS_CHIADO */]: "0x58a41b89f4871725e5d898d98ef4bf917601c5eb",
+    ["EVM-11155111" /* SEPOLIA */]: "0x2EdB74C269948b60ec1000040E104cef0eABaae8",
+    ["EVM-1" /* MAINNET */]: "0x792A6236AF69787C40cF76b69B4c8c7B28c4cA20",
+    ["EVM-56" /* BSC_MAINNET */]: "0x24B5d421Ec373FcA57325dd2F0C074009Af021F7"
+  },
+  UniswapRouter02: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x9639379819420704457B07A0C33B678D9E0F8Df0",
+    ["EVM-10200" /* GNOSIS_CHIADO */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-11155111" /* SEPOLIA */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-1" /* MAINNET */]: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
+    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
+  },
+  UniswapV2Factory: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x12e036669DA18F4A2777853d6e2136b32AceEC86",
+    ["EVM-10200" /* GNOSIS_CHIADO */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-11155111" /* SEPOLIA */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-1" /* MAINNET */]: "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
+    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
+  },
+  BatchExecutor: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x4CC58B5D8FBf838d062E4b21F75C327835B5F0ef",
+    ["EVM-1" /* MAINNET */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
+  },
+  UniversalRouter: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0xcc6d5ece3d4a57245bf5a2f64f3ed9179b81f714",
+    ["EVM-1" /* MAINNET */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
+  },
+  UniswapV3Router: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-1" /* MAINNET */]: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
+  },
+  UniswapV3Factory: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-1" /* MAINNET */]: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
+  },
+  UniswapV3Quoter: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-1" /* MAINNET */]: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
+  },
+  UniswapV4PoolManager: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-1" /* MAINNET */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
+  },
+  UniswapV4Quoter: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-1" /* MAINNET */]: "0x52f0e24d1c21c8a0cb1e5a5dd6198556bd9e1203",
+    ["EVM-56" /* BSC_MAINNET */]: "0x0000000000000000000000000000000000000000"
+  },
+  Calldispatcher: {
+    ["EVM-11155111" /* SEPOLIA */]: "0xC7f13b6D03A0A7F3239d38897503E90553ABe155"
+  }
+};
+var createRpcUrls = (env2) => ({
+  ["EVM-97" /* BSC_CHAPEL */]: env2.BSC_CHAPEL || "https://bnb-testnet.api.onfinality.io/public",
+  ["EVM-10200" /* GNOSIS_CHIADO */]: env2.GNOSIS_CHIADO || "https://gnosis-chiado-rpc.publicnode.com",
+  ["KUSAMA-4009" /* HYPERBRIDGE_GARGANTUA */]: env2.HYPERBRIDGE_GARGANTUA || "",
+  ["EVM-11155111" /* SEPOLIA */]: env2.SEPOLIA || "https://1rpc.io/sepolia",
+  ["EVM-1" /* MAINNET */]: env2.ETH_MAINNET || "https://eth-mainnet.g.alchemy.com/v2/demo",
+  ["EVM-56" /* BSC_MAINNET */]: env2.BSC_MAINNET || "https://binance.llamarpc.com"
+});
+var consensusStateIds = {
+  ["EVM-97" /* BSC_CHAPEL */]: "BSC0",
+  ["EVM-10200" /* GNOSIS_CHIADO */]: "GNO0",
+  ["KUSAMA-4009" /* HYPERBRIDGE_GARGANTUA */]: "PAS0",
+  ["EVM-11155111" /* SEPOLIA */]: "ETH0",
+  ["EVM-1" /* MAINNET */]: "ETH0",
+  ["EVM-56" /* BSC_MAINNET */]: "BSC0"
+};
+
+// src/configs/ChainConfigService.ts
+var ChainConfigService = class {
+  rpcUrls;
+  constructor(env2 = process.env) {
+    this.rpcUrls = createRpcUrls(env2);
+  }
+  getChainConfig(chain) {
+    return {
+      chainId: chainIds[chain],
+      rpcUrl: this.rpcUrls[chain],
+      intentGatewayAddress: addresses.IntentGateway[chain]
+    };
+  }
+  getIntentGatewayAddress(chain) {
+    return addresses.IntentGateway[chain];
+  }
+  getHostAddress(chain) {
+    return addresses.Host[chain];
+  }
+  getWrappedNativeAssetWithDecimals(chain) {
+    return {
+      asset: assets[chain].WETH,
+      decimals: WrappedNativeDecimals[chain]
+    };
+  }
+  getDaiAsset(chain) {
+    return assets[chain].DAI;
+  }
+  getUsdtAsset(chain) {
+    return assets[chain].USDT;
+  }
+  getUsdcAsset(chain) {
+    return assets[chain].USDC;
+  }
+  getChainId(chain) {
+    return chainIds[chain];
+  }
+  getConsensusStateId(chain) {
+    return toHex(consensusStateIds[chain]);
+  }
+  getHyperbridgeChainId() {
+    return chainIds["KUSAMA-4009" /* HYPERBRIDGE_GARGANTUA */];
+  }
+  getRpcUrl(chain) {
+    return this.rpcUrls[chain];
+  }
+  getUniswapRouterV2Address(chain) {
+    return addresses.UniswapRouter02[chain];
+  }
+  getUniswapV2FactoryAddress(chain) {
+    return addresses.UniswapV2Factory[chain];
+  }
+  getBatchExecutorAddress(chain) {
+    return addresses.BatchExecutor[chain];
+  }
+  getUniversalRouterAddress(chain) {
+    return addresses.UniversalRouter[chain];
+  }
+  getUniswapV3RouterAddress(chain) {
+    return addresses.UniswapV3Router[chain];
+  }
+  getUniswapV3FactoryAddress(chain) {
+    return addresses.UniswapV3Factory[chain];
+  }
+  getUniswapV3QuoterAddress(chain) {
+    return addresses.UniswapV3Quoter[chain];
+  }
+  getUniswapV4PoolManagerAddress(chain) {
+    return addresses.UniswapV4PoolManager[chain];
+  }
+  getUniswapV4QuoterAddress(chain) {
+    return addresses.UniswapV4Quoter[chain];
+  }
+};
+
+// src/chains/evm.ts
+var chains = {
+  [mainnet.id]: mainnet,
+  [arbitrum.id]: arbitrum,
+  [arbitrumSepolia.id]: arbitrumSepolia,
+  [optimism.id]: optimism,
+  [optimismSepolia.id]: optimismSepolia,
+  [base.id]: base,
+  [baseSepolia.id]: baseSepolia,
+  [soneium.id]: soneium,
+  [bsc.id]: bsc,
+  [bscTestnet.id]: bscTestnet,
+  [gnosis.id]: gnosis,
+  [gnosisChiado.id]: gnosisChiado
+};
+var DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
+var EvmChain = class {
+  constructor(params) {
+    this.params = params;
+    this.publicClient = createPublicClient({
+      // @ts-ignore
+      chain: chains[params.chainId],
+      transport: http(params.url)
+    });
+    this.chainConfigService = new ChainConfigService();
+  }
+  publicClient;
+  chainConfigService;
+  // Expose minimal getters for external helpers/classes
+  get client() {
+    return this.publicClient;
+  }
+  get host() {
+    return this.params.host;
+  }
+  get config() {
+    return this.chainConfigService;
+  }
+  /**
+   * Derives the key for the request receipt.
+   * @param {HexString} commitment - The commitment to derive the key from.
+   * @returns {HexString} The derived key.
+   */
+  requestReceiptKey(commitment) {
+    return deriveMapKey(hexToBytes(commitment), REQUEST_RECEIPTS_SLOT);
+  }
+  /**
+   * Queries the request receipt.
+   * @param {HexString} commitment - The commitment to query.
+   * @returns {Promise<HexString | undefined>} The relayer address responsible for delivering the request.
+   */
+  async queryRequestReceipt(commitment) {
+    const relayer = await this.publicClient.readContract({
+      address: this.params.host,
+      abi: evmHost_default.ABI,
+      functionName: "requestReceipts",
+      args: [commitment]
+    });
+    return relayer === DEFAULT_ADDRESS ? void 0 : relayer;
+  }
+  /**
+   * Queries the proof of the commitments.
+   * @param {IMessage} message - The message to query.
+   * @param {string} counterparty - The counterparty address.
+   * @param {bigint} [at] - The block number to query at.
+   * @returns {Promise<HexString>} The proof.
+   */
+  async queryProof(message, counterparty, at) {
+    const commitmentKeys = "Requests" in message ? message.Requests.map((key) => requestCommitmentKey(key)) : message.Responses.map((key) => responseCommitmentKey(key));
+    const config = {
+      address: this.params.host,
+      storageKeys: commitmentKeys
+    };
+    if (!at) {
+      config.blockTag = "latest";
+    } else {
+      config.blockNumber = at;
+    }
+    const proof = await this.publicClient.getProof(config);
+    const flattenedProof = Array.from(new Set(flatten(proof.storageProof.map((item) => item.proof))));
+    const encoded = EvmStateProof.enc({
+      contractProof: proof.accountProof.map((item) => Array.from(hexToBytes(item))),
+      storageProof: [
+        [Array.from(hexToBytes(this.params.host)), flattenedProof.map((item) => Array.from(hexToBytes(item)))]
+      ]
+    });
+    return toHex(encoded);
+  }
+  /**
+   * Query and return the encoded storage proof for the provided keys at the given height.
+   * @param {bigint} at - The block height at which to query the storage proof.
+   * @param {HexString[]} keys - The keys for which to query the storage proof.
+   * @returns {Promise<HexString>} The encoded storage proof.
+   */
+  async queryStateProof(at, keys) {
+    const config = {
+      address: this.params.host,
+      storageKeys: keys
+    };
+    if (!at) {
+      config.blockTag = "latest";
+    } else {
+      config.blockNumber = at;
+    }
+    const proof = await this.publicClient.getProof(config);
+    const flattenedProof = Array.from(new Set(flatten(proof.storageProof.map((item) => item.proof))));
+    const encoded = EvmStateProof.enc({
+      contractProof: proof.accountProof.map((item) => Array.from(hexToBytes(item))),
+      storageProof: [
+        [Array.from(hexToBytes(this.params.host)), flattenedProof.map((item) => Array.from(hexToBytes(item)))]
+      ]
+    });
+    return toHex(encoded);
+  }
+  /**
+   * Returns the current timestamp of the chain.
+   * @returns {Promise<bigint>} The current timestamp.
+   */
+  async timestamp() {
+    const data = await this.publicClient.readContract({
+      address: this.params.host,
+      abi: evmHost_default.ABI,
+      functionName: "timestamp"
+    });
+    return BigInt(data);
+  }
+  /**
+   * Get the latest state machine height for a given state machine ID.
+   * @param {StateMachineIdParams} stateMachineId - The state machine ID.
+   * @returns {Promise<bigint>} The latest state machine height.
+   */
+  async latestStateMachineHeight(stateMachineId) {
+    if (!this.publicClient) throw new Error("API not initialized");
+    const id = stateMachineId.stateId.Polkadot || stateMachineId.stateId.Kusama;
+    if (!id)
+      throw new Error(
+        "Expected Polakdot or Kusama State machine id when reading latest state machine height on evm"
+      );
+    const data = await this.publicClient.readContract({
+      address: this.params.host,
+      abi: evmHost_default.ABI,
+      functionName: "latestStateMachineHeight",
+      args: [BigInt(id)]
+    });
+    return data;
+  }
+  /**
+   * Get the state machine update time for a given state machine height.
+   * @param {StateMachineHeight} stateMachineHeight - The state machine height.
+   * @returns {Promise<bigint>} The statemachine update time in seconds.
+   */
+  async stateMachineUpdateTime(stateMachineHeight) {
+    if (!this.publicClient) throw new Error("API not initialized");
+    const id = stateMachineHeight.id.stateId.Polkadot || stateMachineHeight.id.stateId.Kusama;
+    if (!id) throw new Error("Expected Polkadot or Kusama State machine id when reading state machine update time");
+    const data = await this.publicClient.readContract({
+      address: this.params.host,
+      abi: evmHost_default.ABI,
+      functionName: "stateMachineCommitmentUpdateTime",
+      args: [{ stateMachineId: BigInt(id), height: stateMachineHeight.height }]
+    });
+    return data;
+  }
+  /**
+   * Get the challenge period for a given state machine id.
+   * @param {StateMachineIdParams} stateMachineId - The state machine ID.
+   * @returns {Promise<bigint>} The challenge period in seconds.
+   */
+  async challengePeriod(stateMachineId) {
+    if (!this.publicClient) throw new Error("API not initialized");
+    const id = stateMachineId.stateId.Polkadot || stateMachineId.stateId.Kusama;
+    if (!id)
+      throw new Error(
+        "Expected Polkadot or Kusama State machine id when reading latest state machine height on evm"
+      );
+    const data = await this.publicClient.readContract({
+      address: this.params.host,
+      abi: evmHost_default.ABI,
+      functionName: "challengePeriod"
+    });
+    return data;
+  }
+  /**
+   * Encodes an ISMP message for the EVM chain.
+   * @param {IIsmpMessage} message The ISMP message to encode.
+   * @returns {HexString} The encoded calldata.
+   */
+  encode(message) {
+    const encoded = match(message).with({ kind: "PostRequest" }, (request) => {
+      const mmrProof = MmrProof.dec(request.proof.proof);
+      const requests = zip(request.requests, mmrProof.leafIndexAndPos).map(([req, leafIndexAndPos]) => {
+        if (!req || !leafIndexAndPos) return;
+        const [[, kIndex]] = mmrPositionToKIndex(
+          [leafIndexAndPos?.pos],
+          calculateMMRSize(mmrProof.leafCount)
+        );
+        return {
+          request: {
+            source: toHex(req.source),
+            dest: toHex(req.dest),
+            to: req.to,
+            from: req.from,
+            nonce: req.nonce,
+            timeoutTimestamp: req.timeoutTimestamp,
+            body: req.body
+          },
+          index: leafIndexAndPos?.leafIndex,
+          kIndex
+        };
+      }).filter((item) => !!item);
+      const proof = {
+        height: {
+          stateMachineId: BigInt(Number.parseInt(request.proof.stateMachine.split("-")[1])),
+          height: request.proof.height
+        },
+        multiproof: mmrProof.items.map((item) => bytesToHex(new Uint8Array(item))),
+        leafCount: mmrProof.leafCount
+      };
+      const encoded2 = encodeFunctionData({
+        abi: handler_default.ABI,
+        functionName: "handlePostRequests",
+        args: [
+          this.params.host,
+          {
+            proof,
+            requests
+          }
+        ]
+      });
+      return encoded2;
+    }).with({ kind: "TimeoutPostRequest" }, (timeout) => {
+      const proof = SubstrateStateProof.dec(timeout.proof.proof).value.storageProof.map(
+        (item) => toHex(new Uint8Array(item))
+      );
+      const encoded2 = encodeFunctionData({
+        abi: handler_default.ABI,
+        functionName: "handlePostRequestTimeouts",
+        args: [
+          this.params.host,
+          {
+            height: {
+              stateMachineId: BigInt(Number.parseInt(timeout.proof.stateMachine.split("-")[1])),
+              height: timeout.proof.height
+            },
+            timeouts: timeout.requests.map((req) => ({
+              source: toHex(req.source),
+              dest: toHex(req.dest),
+              to: req.to,
+              from: req.from,
+              nonce: req.nonce,
+              timeoutTimestamp: req.timeoutTimestamp,
+              body: req.body
+            })),
+            proof
+          }
+        ]
+      });
+      return encoded2;
+    }).with({ kind: "GetResponse" }, (request) => {
+      const mmrProof = MmrProof.dec(request.proof.proof);
+      const responses = zip(request.responses, mmrProof.leafIndexAndPos).map(([req, leafIndexAndPos]) => {
+        if (!req || !leafIndexAndPos) return;
+        const [[, kIndex]] = mmrPositionToKIndex(
+          [leafIndexAndPos?.pos],
+          calculateMMRSize(mmrProof.leafCount)
+        );
+        return {
+          response: {
+            request: {
+              source: toHex(req.get.source),
+              dest: toHex(req.get.dest),
+              from: req.get.from,
+              nonce: req.get.nonce,
+              timeoutTimestamp: req.get.timeoutTimestamp,
+              keys: req.get.keys,
+              context: req.get.context,
+              height: req.get.height
+            },
+            values: req.values
+          },
+          index: leafIndexAndPos?.leafIndex,
+          kIndex
+        };
+      }).filter((item) => !!item);
+      const proof = {
+        height: {
+          stateMachineId: BigInt(Number.parseInt(request.proof.stateMachine.split("-")[1])),
+          height: request.proof.height
+        },
+        multiproof: mmrProof.items.map((item) => bytesToHex(new Uint8Array(item))),
+        leafCount: mmrProof.leafCount
+      };
+      const encoded2 = encodeFunctionData({
+        abi: handler_default.ABI,
+        functionName: "handleGetResponses",
+        args: [
+          this.params.host,
+          {
+            proof,
+            responses
+          }
+        ]
+      });
+      return encoded2;
+    }).exhaustive();
+    return encoded;
+  }
+  /**
+   * Calculates the fee required to send a post request to the destination chain.
+   * The fee is calculated based on the per-byte fee for the destination chain
+   * multiplied by the size of the request body.
+   *
+   * @param request - The post request to calculate the fee for
+   * @returns The total fee in wei required to send the post request
+   */
+  async quote(request) {
+    const perByteFee = await this.publicClient.readContract({
+      address: this.params.host,
+      abi: evmHost_default.ABI,
+      functionName: "perByteFee",
+      args: [toHex(request.dest)]
+    });
+    const bodyByteLength = Math.floor((request.body.length - 2) / 2);
+    const length = bodyByteLength < 32 ? 32 : bodyByteLength;
+    return perByteFee * BigInt(length);
+  }
+  /**
+   * Estimates the gas required for a post request execution on this chain.
+   * This function generates mock proofs for the post request, creates a state override
+   * with the necessary overlay root, and estimates the gas cost for executing the
+   * handlePostRequests transaction on the handler contract.
+   *
+   * @param request - The post request to estimate gas for
+   * @param paraId - The ID of the parachain (Hyperbridge) that will process the request
+   * @returns The estimated gas amount in gas units
+   */
+  async estimateGas(request) {
+    const hostParams = await this.publicClient.readContract({
+      address: this.params.host,
+      abi: evmHost_default.ABI,
+      functionName: "hostParams"
+    });
+    const { root, proof, index, kIndex, treeSize } = await generateRootWithProof(request, 2n ** 10n);
+    const latestStateMachineHeight = 6291991n;
+    const paraId = 4009n;
+    const overlayRootSlot = getStateCommitmentFieldSlot(
+      paraId,
+      // Hyperbridge chain id
+      latestStateMachineHeight,
+      // Hyperbridge chain height
+      1
+      // For overlayRoot
+    );
+    const postParams = {
+      height: {
+        stateMachineId: BigInt(paraId),
+        height: latestStateMachineHeight
+      },
+      multiproof: proof,
+      leafCount: treeSize
+    };
+    const gas = await this.publicClient.estimateContractGas({
+      address: hostParams.handler,
+      abi: handler_default.ABI,
+      functionName: "handlePostRequests",
+      args: [
+        this.params.host,
+        {
+          proof: postParams,
+          requests: [
+            {
+              request: {
+                ...request,
+                source: toHex(request.source),
+                dest: toHex(request.dest)
+              },
+              index,
+              kIndex
+            }
+          ]
+        }
+      ],
+      stateOverride: [
+        {
+          address: this.params.host,
+          stateDiff: [
+            {
+              slot: overlayRootSlot,
+              value: root
+            }
+          ]
+        }
+      ]
+    });
+    return gas;
+  }
+  /**
+   * Gets the fee token address and decimals for the chain.
+   * This function gets the fee token address and decimals for the chain.
+   *
+   * @returns The fee token address and decimals
+   */
+  async getFeeTokenWithDecimals() {
+    const hostParams = await this.publicClient.readContract({
+      abi: evmHost_default.ABI,
+      address: this.params.host,
+      functionName: "hostParams"
+    });
+    const feeTokenAddress = hostParams.feeToken;
+    const feeTokenDecimals = await this.publicClient.readContract({
+      address: feeTokenAddress,
+      abi: erc20Abi,
+      functionName: "decimals"
+    });
+    return { address: feeTokenAddress, decimals: feeTokenDecimals };
+  }
+  /**
+   * Gets the nonce of the host.
+   * This function gets the nonce of the host.
+   *
+   * @returns The nonce of the host
+   */
+  async getHostNonce() {
+    const nonce = await this.publicClient.readContract({
+      abi: evmHost_default.ABI,
+      address: this.params.host,
+      functionName: "nonce"
+    });
+    return nonce;
+  }
+};
+var REQUEST_COMMITMENTS_SLOT = 0n;
+var RESPONSE_COMMITMENTS_SLOT = 1n;
+var REQUEST_RECEIPTS_SLOT = 2n;
+var RESPONSE_RECEIPTS_SLOT = 3n;
+var STATE_COMMITMENTS_SLOT = 5n;
+function requestCommitmentKey(key) {
+  const keyBytes = hexToBytes(key);
+  const slot = REQUEST_COMMITMENTS_SLOT;
+  const mappedKey = deriveMapKey(keyBytes, slot);
+  const number = bytesToBigInt(hexToBytes(mappedKey)) + 1n;
+  return pad(`0x${number.toString(16)}`, { size: 32 });
+}
+function responseCommitmentKey(key) {
+  const keyBytes = hexToBytes(key);
+  const slot = RESPONSE_COMMITMENTS_SLOT;
+  const mappedKey = deriveMapKey(keyBytes, slot);
+  const number = bytesToBigInt(hexToBytes(mappedKey)) + 1n;
+  return pad(`0x${number.toString(16)}`, { size: 32 });
+}
+function deriveMapKey(key, slot) {
+  const slotBytes = pad(`0x${slot.toString(16)}`, { size: 32 });
+  const combined = new Uint8Array([...key, ...toBytes(slotBytes)]);
+  return keccak256(combined);
+}
+function getStateCommitmentFieldSlot(stateMachineId, height, field) {
+  const baseSlot = getStateCommitmentSlot(stateMachineId, height);
+  const slotNumber = bytesToBigInt(toBytes(baseSlot)) + BigInt(field);
+  return pad(`0x${slotNumber.toString(16)}`, { size: 32 });
+}
+function getStateCommitmentSlot(stateMachineId, height) {
+  const firstLevelSlot = deriveFirstLevelSlot(stateMachineId, STATE_COMMITMENTS_SLOT);
+  return deriveSecondLevelSlot(height, firstLevelSlot);
+}
+function deriveFirstLevelSlot(key, slot) {
+  const keyHex = pad(`0x${key.toString(16)}`, { size: 32 });
+  const keyBytes = toBytes(keyHex);
+  const slotBytes = toBytes(pad(`0x${slot.toString(16)}`, { size: 32 }));
+  const combined = new Uint8Array([...keyBytes, ...slotBytes]);
+  return keccak256(combined);
+}
+function deriveSecondLevelSlot(key, firstLevelSlot) {
+  const keyHex = pad(`0x${key.toString(16)}`, { size: 32 });
+  const keyBytes = toBytes(keyHex);
+  const slotBytes = toBytes(firstLevelSlot);
+  const combined = new Uint8Array([...keyBytes, ...slotBytes]);
+  return keccak256(combined);
+}
+var SubstrateChain = class {
+  constructor(params) {
+    this.params = params;
+  }
   /*
-   * There are no proofs for Get timeouts
+   * api: The Polkadot API instance for the Substrate chain.
    */
-  Get: Struct({
-    /*
-     * Timed out requests
-     */
-    requests: Vector(Request)
-  })
-});
-var Message = Enum({
+  api;
   /*
-   * A consensus update message
+   * connect: Connects to the Substrate chain using the provided WebSocket URL.
    */
-  ConsensusMessage,
-  /*
-   * A fraud proof message
+  async connect() {
+    const wsProvider = new WsProvider(this.params.ws);
+    const typesBundle = this.params.hasher === "Keccak" ? {
+      spec: {
+        nexus: {
+          hasher: keccakAsU8a
+        },
+        gargantua: {
+          hasher: keccakAsU8a
+        }
+      }
+    } : {};
+    this.api = await ApiPromise.create({
+      provider: wsProvider,
+      typesBundle
+    });
+  }
+  /**
+   * Disconnects the Substrate chain connection.
    */
-  FraudProofMessage,
-  /*
-   * A request message
+  async disconnect() {
+    if (this.api) {
+      await this.api.disconnect();
+      this.api = void 0;
+    }
+  }
+  /**
+   * Returns the storage key for a request receipt in the child trie
+   * The request commitment is the key
+   * @param key - The H256 hash key (as a 0x-prefixed hex string)
+   * @returns The storage key as a hex string
    */
-  RequestMessage,
-  /*
-   * A response message
+  requestReceiptKey(key) {
+    const prefix = new TextEncoder().encode("RequestReceipts");
+    const keyBytes = hexToBytes(key);
+    return bytesToHex(new Uint8Array([...prefix, ...keyBytes]));
+  }
+  /**
+   * Returns the storage key for a request commitment in the child trie
+   * The request commitment is the key
+   * @param key - The H256 hash key (as a 0x-prefixed hex string)
+   * @returns The storage key as a hex string
    */
-  ResponseMessage,
-  /*
-   * A request timeout message
+  requestCommitmentKey(key) {
+    const prefix = new TextEncoder().encode("RequestCommitments");
+    const keyBytes = hexToBytes(key);
+    return bytesToHex(new Uint8Array([...prefix, ...keyBytes]));
+  }
+  /**
+   * Queries a request commitment from the ISMP child trie storage.
+   * @param {HexString} commitment - The commitment hash to look up.
+   * @returns {Promise<HexString | undefined>} The commitment data if found, undefined otherwise.
    */
-  TimeoutMessage
-});
-
-// src/utils.ts
-var DEFAULT_POLL_INTERVAL = 5e3;
-var ADDRESS_ZERO2 = "0x0000000000000000000000000000000000000000";
-var MOCK_ADDRESS2 = "0x1234567890123456789012345678901234567890";
-var DUMMY_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000000000000000";
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms || DEFAULT_POLL_INTERVAL));
-}
-async function waitForChallengePeriod(chain, stateMachineHeight) {
-  const challengePeriod = await chain.challengePeriod(stateMachineHeight.id);
-  if (challengePeriod === BigInt(0)) return;
-  const updateTime = await chain.stateMachineUpdateTime(stateMachineHeight);
-  let currentTimestamp = await chain.timestamp();
-  let timeElapsed = currentTimestamp - updateTime;
-  if (timeElapsed > challengePeriod) return;
-  await sleep(Number(challengePeriod) * 1e3);
-  while (timeElapsed <= challengePeriod) {
-    const remainingTime = challengePeriod - timeElapsed;
-    await sleep(Number(remainingTime) * 1e3);
-    currentTimestamp = await chain.timestamp();
-    timeElapsed = currentTimestamp - updateTime;
+  async queryRequestCommitment(commitment) {
+    const prefix = toHex(":child_storage:default:ISMP");
+    const key = this.requestCommitmentKey(commitment);
+    const rpc = new RpcWebSocketClient();
+    await rpc.connect(this.params.ws);
+    const item = await rpc.call("childstate_getStorage", [prefix, key]);
+    return item;
   }
-}
-function isEvmChain(stateMachineId) {
-  return stateMachineId.startsWith("EVM");
-}
-function isSubstrateChain(stateMachineId) {
-  return stateMachineId.startsWith("POLKADOT") || stateMachineId.startsWith("KUSAMA") || stateMachineId.startsWith("SUBSTRATE");
-}
-function parseStateMachineId(stateMachineId) {
-  const [type, value] = stateMachineId.split("-");
-  if (!type || !value) {
-    throw new Error(
-      `Invalid state machine ID format: ${stateMachineId}. Expected format like "EVM-97" or "SUBSTRATE-cere"`
-    );
+  /**
+   * Queries the request receipt.
+   * @param {HexString} commitment - The commitment to query.
+   * @returns {Promise<HexString | undefined>} The relayer address responsible for delivering the request.
+   */
+  async queryRequestReceipt(commitment) {
+    const prefix = toHex(":child_storage:default:ISMP");
+    const key = this.requestReceiptKey(commitment);
+    const rpc = new RpcWebSocketClient();
+    await rpc.connect(this.params.ws);
+    const item = await rpc.call("childstate_getStorage", [prefix, key]);
+    return item;
   }
-  const stateId = {};
-  switch (type.toUpperCase()) {
-    case "EVM": {
-      const evmChainId = Number.parseInt(value, 10);
-      if (Number.isNaN(evmChainId)) {
-        throw new Error(`Invalid EVM chain ID: ${value}. Expected a number.`);
-      }
-      stateId.Evm = evmChainId;
-      break;
-    }
-    case "SUBSTRATE": {
-      const bytes = Buffer.from(value, "utf8");
-      stateId.Substrate = `0x${bytes.toString("hex")}`;
-      break;
-    }
-    case "POLKADOT": {
-      const polkadotChainId = Number.parseInt(value, 10);
-      if (Number.isNaN(polkadotChainId)) {
-        throw new Error(`Invalid Polkadot chain ID: ${value}. Expected a number.`);
-      }
-      stateId.Polkadot = polkadotChainId;
-      break;
+  /**
+   * Returns the current timestamp of the chain.
+   * @returns {Promise<bigint>} The current timestamp.
+   */
+  async timestamp() {
+    if (!this.api) throw new Error("API not initialized");
+    const now = await this.api.query.timestamp.now();
+    return BigInt(now.toJSON()) / BigInt(1e3);
+  }
+  /**
+   * Queries the proof of the commitments.
+   * @param {IMessage} message - The message to query.
+   * @param {string} counterparty - The counterparty address.
+   * @param {bigint} [at] - The block number to query at.
+   * @returns {Promise<HexString>} The proof.
+   */
+  async queryProof(message, counterparty, at) {
+    const rpc = new RpcWebSocketClient();
+    await rpc.connect(this.params.ws);
+    if (isEvmChain(counterparty)) {
+      const proof = await rpc.call("mmr_queryProof", [Number(at), message]);
+      return toHex(proof.proof);
     }
-    case "KUSAMA": {
-      const kusamaChainId = Number.parseInt(value, 10);
-      if (Number.isNaN(kusamaChainId)) {
-        throw new Error(`Invalid Kusama chain ID: ${value}. Expected a number.`);
-      }
-      stateId.Kusama = kusamaChainId;
-      break;
+    if (isSubstrateChain(counterparty)) {
+      const childTrieKeys = "Requests" in message ? message.Requests.map(requestCommitmentStorageKey) : message.Responses.map(responseCommitmentStorageKey);
+      const proof = await rpc.call("ismp_queryChildTrieProof", [Number(at), childTrieKeys]);
+      const basicProof = BasicProof.dec(toHex(proof.proof));
+      const encoded = SubstrateStateProof.enc({
+        tag: "OverlayProof",
+        value: {
+          hasher: {
+            tag: this.params.hasher,
+            value: void 0
+          },
+          storageProof: basicProof
+        }
+      });
+      return toHex(encoded);
     }
-    default:
-      throw new Error(`Unsupported chain type: ${type}. Expected one of: EVM, SUBSTRATE, POLKADOT, KUSAMA.`);
+    throw new ExpectedError(`Unsupported chain type for counterparty: ${counterparty}`);
   }
-  return { stateId };
-}
-function postRequestCommitment(post) {
-  const data = encodePacked(
-    ["bytes", "bytes", "uint64", "uint64", "bytes", "bytes", "bytes"],
-    [toHex(post.source), toHex(post.dest), post.nonce, post.timeoutTimestamp, post.from, post.to, post.body]
-  );
-  return {
-    commitment: keccak256(data),
-    encodePacked: data
-  };
-}
-function orderCommitment2(order) {
-  const encodedOrder = encodeAbiParameters(
-    [
-      {
-        name: "order",
-        type: "tuple",
-        components: [
-          { name: "user", type: "bytes32" },
-          { name: "sourceChain", type: "bytes" },
-          { name: "destChain", type: "bytes" },
-          { name: "deadline", type: "uint256" },
-          { name: "nonce", type: "uint256" },
-          { name: "fees", type: "uint256" },
-          {
-            name: "outputs",
-            type: "tuple[]",
-            components: [
-              { name: "token", type: "bytes32" },
-              { name: "amount", type: "uint256" },
-              { name: "beneficiary", type: "bytes32" }
-            ]
-          },
-          {
-            name: "inputs",
-            type: "tuple[]",
-            components: [
-              { name: "token", type: "bytes32" },
-              { name: "amount", type: "uint256" }
-            ]
-          },
-          { name: "callData", type: "bytes" }
-        ]
-      }
-    ],
-    [
-      {
-        user: order.user,
-        sourceChain: order.sourceChain.startsWith("0x") ? order.sourceChain : toHex(order.sourceChain),
-        destChain: order.destChain.startsWith("0x") ? order.destChain : toHex(order.destChain),
-        deadline: order.deadline,
-        nonce: order.nonce,
-        fees: order.fees,
-        outputs: order.outputs,
-        inputs: order.inputs,
-        callData: order.callData
+  /**
+   * Submit an unsigned ISMP transaction to the chain. Resolves when the transaction is finalized.
+   * @param message - The message to be submitted.
+   * @returns A promise that resolves to an object containing the transaction hash, block hash, and block number.
+   */
+  async submitUnsigned(message) {
+    if (!this.api) throw new Error("API not initialized");
+    const { api } = this;
+    const args = hexToBytes(this.encode(message)).slice(2);
+    const tx = api.tx.ismp.handleUnsigned(args);
+    return new Promise((resolve, reject) => {
+      let unsub = () => {
+      };
+      tx.send(async ({ isInBlock, isFinalized, isError, dispatchError, txHash, status }) => {
+        if (isFinalized || isInBlock) {
+          unsub();
+          const blockHash = isInBlock ? status.asInBlock.toHex() : status.asFinalized.toHex();
+          const header = await api.rpc.chain.getHeader(blockHash);
+          const apiAt = await api.at(blockHash);
+          const timestamp = await apiAt.query.timestamp.now();
+          resolve({
+            transactionHash: txHash.toHex(),
+            blockHash,
+            blockNumber: header.number.toNumber(),
+            timestamp: Number(timestamp.toJSON()) / 1e3
+          });
+        } else if (isError) {
+          unsub();
+          console.error("Unsigned transaction failed: ", dispatchError);
+          reject(dispatchError);
+        }
+      }).then((unsubscribe) => {
+        unsub = unsubscribe;
+      }).catch(reject);
+    });
+  }
+  /**
+   * Query the state proof for a given set of keys at a specific block height.
+   * @param at The block height to query the state proof at.
+   * @param keys The keys to query the state proof for.
+   * @returns The state proof as a hexadecimal string.
+   */
+  async queryStateProof(at, keys) {
+    const rpc = new RpcWebSocketClient();
+    await rpc.connect(this.params.ws);
+    const encodedKeys = keys.map((key) => Array.from(hexToBytes(key)));
+    const proof = await rpc.call("ismp_queryChildTrieProof", [Number(at), encodedKeys]);
+    const basicProof = BasicProof.dec(toHex(proof.proof));
+    const encoded = SubstrateStateProof.enc({
+      tag: "OverlayProof",
+      value: {
+        hasher: {
+          tag: this.params.hasher,
+          value: void 0
+        },
+        storageProof: basicProof
       }
-    ]
-  );
-  return keccak256(encodedOrder);
-}
-function bytes32ToBytes202(bytes32Address) {
-  if (bytes32Address === ADDRESS_ZERO2) {
-    return ADDRESS_ZERO2;
+    });
+    return toHex(encoded);
   }
-  const bytes = hexToBytes(bytes32Address);
-  const addressBytes = bytes.slice(12);
-  return bytesToHex(addressBytes);
-}
-function bytes20ToBytes32(bytes20Address) {
-  return `0x${bytes20Address.slice(2).padStart(64, "0")}`;
-}
-function hexToString2(hex) {
-  const hexWithoutPrefix = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = new Uint8Array(hexWithoutPrefix.length / 2);
-  for (let i = 0; i < hexWithoutPrefix.length; i += 2) {
-    bytes[i / 2] = Number.parseInt(hexWithoutPrefix.slice(i, i + 2), 16);
+  /**
+   * Get the latest state machine height for a given state machine ID.
+   * @param {StateMachineIdParams} stateMachineId - The state machine ID.
+   * @returns {Promise<bigint>} The latest state machine height.
+   */
+  async latestStateMachineHeight(stateMachineId) {
+    if (!this.api) throw new Error("API not initialized");
+    const latestHeight = await this.api.query.ismp.latestStateMachineHeight(stateMachineId);
+    return BigInt(latestHeight.toString());
   }
-  return new TextDecoder().decode(bytes);
-}
-var DEFAULT_LOGGER = createConsola({
-  level: LogLevels.silent
-});
-async function retryPromise(operation, retryConfig) {
-  const { logger = DEFAULT_LOGGER, logMessage = "Retry operation failed" } = retryConfig;
-  let lastError;
-  for (let i = 0; i < retryConfig.maxRetries; i++) {
-    try {
-      return await operation();
-    } catch (error) {
-      logger.trace(`Retrying(${i}) > ${logMessage}`);
-      lastError = error;
-      await new Promise((resolve) => setTimeout(resolve, retryConfig.backoffMs * 2 ** i));
-    }
+  /**
+   * Get the state machine update time for a given state machine height.
+   * @param {StateMachineHeight} stateMachineHeight - The state machine height.
+   * @returns {Promise<bigint>} The statemachine update time in seconds.
+   */
+  async stateMachineUpdateTime(stateMachineHeight) {
+    if (!this.api) throw new Error("API not initialized");
+    const updateTime = await this.api.query.ismp.stateMachineUpdateTime(stateMachineHeight);
+    return BigInt(updateTime.toString());
+  }
+  /**
+   * Get the challenge period for a given state machine id.
+   * @param {StateMachineIdParams} stateMachineId - The state machine ID.
+   * @returns {Promise<bigint>} The challenge period in seconds.
+   */
+  async challengePeriod(stateMachineId) {
+    if (!this.api) throw new Error("API not initialized");
+    const challengePeriod = await this.api.query.ismp.challengePeriod(stateMachineId);
+    return BigInt(challengePeriod.toString());
+  }
+  /**
+   * Encode an ISMP calldata for a substrate chain.
+   * @param message The ISMP message to encode.
+   * @returns The encoded message as a hexadecimal string.
+   */
+  encode(message) {
+    const palletIndex = this.getPalletIndex("Ismp");
+    const args = encodeISMPMessage(message);
+    const call = Vector(u8, 2).enc([palletIndex, 0]);
+    return toHex(new Uint8Array([...call, ...args]));
+  }
+  /**
+   * Returns the index of a pallet by its name, by looking up the pallets in the runtime metadata.
+   * @param {string} name - The name of the pallet.
+   * @returns {number} The index of the pallet.
+   */
+  getPalletIndex(name) {
+    if (!this.api) throw new Error("API not initialized");
+    const pallets = this.api.runtimeMetadata.asLatest.pallets.entries();
+    for (const p of pallets) {
+      if (p[1].name.toString() === name) {
+        const index = p[1].index.toNumber();
+        return index;
+      }
+    }
+    throw new Error(`${name} not found in runtime`);
   }
-  throw lastError;
-}
-function getRequestCommitment(get) {
-  const keysEncoding = "0x".concat(get.keys.map((key) => key.slice(2)).join(""));
-  return keccak256(
-    encodePacked(
-      ["bytes", "bytes", "uint64", "uint64", "uint64", "bytes", "bytes", "bytes"],
-      [
-        toHex(get.source),
-        toHex(get.dest),
-        get.nonce,
-        get.height,
-        get.timeoutTimestamp,
-        get.from,
-        keysEncoding,
-        get.context
-      ]
-    )
-  );
-}
-var REQUEST_STATUS_WEIGHTS = {
-  [RequestStatus.SOURCE]: 0,
-  [RequestStatus.SOURCE_FINALIZED]: 1,
-  [RequestStatus.HYPERBRIDGE_DELIVERED]: 2,
-  [RequestStatus.HYPERBRIDGE_FINALIZED]: 3,
-  [RequestStatus.DESTINATION]: 4,
-  [RequestStatus.HYPERBRIDGE_TIMED_OUT]: 5,
-  [RequestStatus.TIMED_OUT]: 6
-};
-var TIMEOUT_STATUS_WEIGHTS = {
-  [TimeoutStatus.PENDING_TIMEOUT]: 1,
-  [TimeoutStatus.DESTINATION_FINALIZED_TIMEOUT]: 2,
-  [TimeoutStatus.HYPERBRIDGE_TIMED_OUT]: 3,
-  [TimeoutStatus.HYPERBRIDGE_FINALIZED_TIMEOUT]: 4,
-  [TimeoutStatus.TIMED_OUT]: 5
-};
-var COMBINED_STATUS_WEIGHTS = {
-  [RequestStatus.SOURCE]: 0,
-  [RequestStatus.SOURCE_FINALIZED]: 1,
-  [RequestStatus.HYPERBRIDGE_DELIVERED]: 2,
-  [RequestStatus.HYPERBRIDGE_FINALIZED]: 3,
-  [RequestStatus.DESTINATION]: 4,
-  [TimeoutStatus.PENDING_TIMEOUT]: 5,
-  [TimeoutStatus.DESTINATION_FINALIZED_TIMEOUT]: 6,
-  [TimeoutStatus.HYPERBRIDGE_TIMED_OUT]: 7,
-  [TimeoutStatus.HYPERBRIDGE_FINALIZED_TIMEOUT]: 8,
-  [TimeoutStatus.TIMED_OUT]: 9
 };
-async function estimateGasForPost(params) {
-  const hostParams = await params.sourceClient.readContract({
-    address: params.hostAddress,
-    abi: evmHost_default.ABI,
-    functionName: "hostParams"
-  });
-  const { root, proof, index, kIndex, treeSize } = await generateRootWithProof(params.postRequest, 2n ** 10n);
-  const latestStateMachineHeight = params.hostLatestStateMachineHeight;
-  const overlayRootSlot = getStateCommitmentFieldSlot(
-    BigInt(4009n),
-    // Hyperbridge chain id
-    latestStateMachineHeight,
-    // Hyperbridge chain height
-    1
-    // For overlayRoot
-  );
-  const postParams = {
-    height: {
-      stateMachineId: BigInt(4009n),
-      height: latestStateMachineHeight
-    },
-    multiproof: proof,
-    leafCount: treeSize
+function requestCommitmentStorageKey(key) {
+  const prefix = new TextEncoder().encode("RequestCommitments");
+  const keyBytes = hexToBytes(key);
+  return Array.from(new Uint8Array([...prefix, ...keyBytes]));
+}
+function responseCommitmentStorageKey(key) {
+  const prefix = new TextEncoder().encode("ResponseCommitments");
+  const keyBytes = hexToBytes(key);
+  return Array.from(new Uint8Array([...prefix, ...keyBytes]));
+}
+function convertStateMachineIdToEnum(id) {
+  let [tag, value] = id.split("-");
+  tag = capitalize(tag);
+  if (["Evm", "Polkadot", "Kusama"].includes(tag)) {
+    value = Number.parseInt(value);
+  } else {
+    value = Array.from(toBytes(value));
+  }
+  return { tag, value };
+}
+function convertIPostRequestToCodec(request) {
+  return {
+    tag: "Post",
+    value: {
+      source: convertStateMachineIdToEnum(request.source),
+      dest: convertStateMachineIdToEnum(request.dest),
+      from: Array.from(hexToBytes(request.from)),
+      to: Array.from(hexToBytes(request.to)),
+      nonce: request.nonce,
+      body: Array.from(hexToBytes(request.body)),
+      timeoutTimestamp: request.timeoutTimestamp
+    }
   };
-  const gas = await params.sourceClient.estimateContractGas({
-    address: hostParams.handler,
-    abi: handler_default.ABI,
-    functionName: "handlePostRequests",
-    args: [
-      params.hostAddress,
-      {
-        proof: postParams,
-        requests: [
-          {
-            request: {
-              ...params.postRequest,
-              source: toHex(params.postRequest.source),
-              dest: toHex(params.postRequest.dest)
+}
+function encodeISMPMessage(message) {
+  try {
+    return match(message).with({ kind: "PostRequest" }, (message2) => {
+      return Vector(Message).enc([
+        {
+          tag: "RequestMessage",
+          value: {
+            requests: message2.requests.map(
+              (post_request) => convertIPostRequestToCodec(post_request).value
+            ),
+            proof: {
+              height: {
+                height: message2.proof.height,
+                id: {
+                  consensusStateId: Array.from(toBytes(message2.proof.consensusStateId)),
+                  id: convertStateMachineIdToEnum(message2.proof.stateMachine)
+                }
+              },
+              proof: Array.from(hexToBytes(message2.proof.proof))
             },
-            index,
-            kIndex
+            signer: Array.from(hexToBytes(message2.signer))
           }
-        ]
-      }
-    ],
-    stateOverride: [
-      {
-        address: params.hostAddress,
-        stateDiff: [
-          {
-            slot: overlayRootSlot,
-            value: root
+        }
+      ]);
+    }).with({ kind: "GetResponse" }, (message2) => {
+      throw new Error("GetResponse is not yet supported on Substrate chains");
+    }).with({ kind: "TimeoutPostRequest" }, (message2) => {
+      return Vector(Message).enc([
+        {
+          tag: "TimeoutMessage",
+          value: {
+            tag: "Post",
+            value: {
+              requests: message2.requests.map((r) => convertIPostRequestToCodec(r)),
+              proof: {
+                height: {
+                  height: message2.proof.height,
+                  id: {
+                    consensusStateId: Array.from(toBytes(message2.proof.consensusStateId)),
+                    id: convertStateMachineIdToEnum(message2.proof.stateMachine)
+                  }
+                },
+                proof: Array.from(hexToBytes(message2.proof.proof))
+              }
+            }
           }
-        ]
-      }
-    ]
-  });
-  return gas;
+        }
+      ]);
+    }).exhaustive();
+  } catch (error) {
+    throw new Error("Failed to encode ISMP message", { cause: error });
+  }
 }
-function constructRedeemEscrowRequestBody2(order, beneficiary) {
-  const commitment = order.id;
-  const inputs = order.inputs;
-  const requestKind = encodePacked(["uint8"], [0 /* RedeemEscrow */]);
-  const requestBody = {
-    commitment,
-    beneficiary: bytes20ToBytes32(beneficiary),
-    tokens: inputs
-  };
-  const encodedRequestBody = encodeAbiParameters(
-    [
-      {
-        name: "requestBody",
-        type: "tuple",
-        components: [
-          { name: "commitment", type: "bytes32" },
-          { name: "beneficiary", type: "bytes32" },
-          {
-            name: "tokens",
-            type: "tuple[]",
-            components: [
-              { name: "token", type: "bytes32" },
-              { name: "amount", type: "uint256" }
-            ]
-          }
-        ]
-      }
-    ],
-    [requestBody]
-  );
-  return concatHex([requestKind, encodedRequestBody]);
+
+// src/chain.ts
+async function getChain(chainConfig) {
+  if (isEvmChain(chainConfig.stateMachineId)) {
+    const config = chainConfig;
+    const chainId = Number.parseInt(chainConfig.stateMachineId.split("-")[1]);
+    const evmChain = new EvmChain({
+      chainId,
+      url: config.rpcUrl,
+      host: config.host
+    });
+    return evmChain;
+  }
+  if (isSubstrateChain(chainConfig.stateMachineId)) {
+    const config = chainConfig;
+    const substrateChain = new SubstrateChain({
+      ws: config.wsUrl,
+      hasher: config.hasher
+    });
+    await substrateChain.connect();
+    return substrateChain;
+  }
+  throw new ExpectedError(`Unsupported chain: ${chainConfig.stateMachineId}`);
 }
-var dateStringtoTimestamp = (date) => {
-  if (!date.endsWith("Z")) {
-    date = `${date}Z`;
+
+// src/queries.ts
+var POST_REQUEST_STATUS = `
+  query RequestStatusM($hash: String!) {
+  requests(
+    filter: { commitment: { equalTo: $hash } }
+  ) {
+    nodes {
+      commitment
+      timeoutTimestamp
+      source
+      dest
+      to
+      from
+      nonce
+      body
+      statusMetadata {
+        nodes {
+          blockHash
+          blockNumber
+          timestamp
+          chain
+          status
+          transactionHash
+        }
+      }
+    }
   }
-  return new Date(date).getTime();
-};
-function mapTestnetToMainnet(identifier) {
-  identifier = identifier.toLowerCase();
-  switch (identifier) {
-    case "bnb":
-      return "wbnb";
-    case "eth":
-      return "weth";
-    case "tbnb":
-      return "wbnb";
-    case "0xc043f483373072f7f27420d6e7d7ad269c018e18".toLowerCase():
-      return "dai";
-    case "0xae13d989dac2f0debff460ac112a837c89baa7cd".toLowerCase():
-      return "wbnb";
-    case "0x1938165569A5463327fb206bE06d8D9253aa06b7".toLowerCase():
-      return "dai";
-    case "0xC625ec7D30A4b1AAEfb1304610CdAcD0d606aC92".toLowerCase():
-      return "dai";
-    case "0x50B1d3c7c073c9caa1Ef207365A2c9C976bD70b9".toLowerCase():
-      return "dai";
-    case "0xa801da100bf16d07f668f4a49e1f71fc54d05177".toLowerCase():
-      return "dai";
-    default:
-      return identifier;
+}
+`;
+var GET_REQUEST_STATUS = `
+query GetRequestDetails($commitment: String!) {
+  getRequests(
+    filter: { commitment: { equalTo: $commitment } }
+  ) {
+    nodes {
+      id
+      source
+      dest
+      from
+      keys
+      nonce
+      height
+      context
+      timeoutTimestamp
+      fee
+      blockNumber
+      blockHash
+      transactionHash
+      blockTimestamp
+      status
+      chain
+      commitment
+      statusMetadata {
+        nodes {
+          status
+          chain
+          timestamp
+          blockNumber
+          blockHash
+          transactionHash
+        }
+      }
+    }
   }
-}
-async function fetchTokenUsdPrice2(identifier) {
-  try {
-    const coinGeckoPrice = await fetchFromCoinGecko(identifier);
-    return coinGeckoPrice;
-  } catch (error) {
-    try {
-      const defillamaPrice = await fetchFromDefillama(identifier);
-      return defillamaPrice;
-    } catch (fallbackError) {
-      console.log(
-        `Both APIs failed for ${identifier}. CoinGecko: ${error}, Defillama: ${fallbackError}. Returning 1`
-      );
-      return 1;
+}`;
+var STATE_MACHINE_UPDATES_BY_HEIGHT = `
+query StateMachineUpdatesByHeight($statemachineId: String!, $height: Int!, $chain: String!) {
+	stateMachineUpdateEvents(
+		filter: {
+			and: [
+				{ stateMachineId: { equalTo: $statemachineId } }
+				{ height: { greaterThanOrEqualTo: $height } }
+				{ chain: { equalTo: $chain } }
+			]
+		}
+		orderBy: HEIGHT_ASC
+		first: 1
+	) {
+    nodes {
+      height
+      stateMachineId
+      chain
+      blockHash
+      blockNumber
+      transactionHash
+      createdAt
     }
   }
 }
-async function fetchFromCoinGecko(identifier) {
-  const mappedIdentifier = mapTestnetToMainnet(identifier);
-  const url = mappedIdentifier.startsWith("0x") ? `https://api.coingecko.com/api/v3/simple/token_price/ethereum?contract_addresses=${mappedIdentifier}&vs_currencies=usd` : `https://api.coingecko.com/api/v3/simple/price?ids=${mappedIdentifier}&vs_currencies=usd`;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`CoinGecko API error: ${response.status} ${response.statusText}`);
+`;
+var STATE_MACHINE_UPDATES_BY_TIMESTAMP = `
+query StateMachineUpdatesByTimestamp($statemachineId: String!, $commitmentTimestamp: BigFloat!, $chain: String!) {
+	stateMachineUpdateEvents(
+		filter: {
+			and: [
+				{ stateMachineId: { equalTo: $statemachineId } }
+				{ commitmentTimestamp: { greaterThanOrEqualTo: $commitmentTimestamp } }
+     			{ chain: { equalTo: $chain } }
+			]
+		}
+		orderBy: COMMITMENT_TIMESTAMP_DESC
+		first: 1
+	) {
+    nodes {
+        height
+        stateMachineId
+        chain
+        blockHash
+        blockNumber
+        transactionHash
+        commitmentTimestamp
+        createdAt
+      }
+    }
   }
-  const data = await response.json();
-  const key = mappedIdentifier.toLowerCase();
-  if (!data[key]?.usd) {
-    throw new Error(`Price not found for token: ${mappedIdentifier}`);
+`;
+var ASSET_TELEPORTED_BY_PARAMS = `
+query AssetTeleportedByParams($from: String!, $to: String!, $dest: String!, $blockNumber: Int!) {
+  assetTeleporteds(
+    filter: {
+      and: [
+        { from: { equalTo: $from } }
+        { to: { equalTo: $to } }
+        { dest: { includes: $dest } }
+        { blockNumber: { greaterThanOrEqualTo: $blockNumber } }
+      ]
+    }
+    orderBy: CREATED_AT_DESC
+    first: 1
+  ) {
+    nodes {
+      id
+      from
+      to
+      amount
+      dest
+      commitment
+      createdAt
+      blockNumber
+    }
   }
-  return data[key].usd;
 }
-async function fetchFromDefillama(identifier) {
-  const mappedIdentifier = mapTestnetToMainnet(identifier);
-  const coinId = mappedIdentifier.startsWith("0x") ? `ethereum:${mappedIdentifier}` : `coingecko:${mappedIdentifier}`;
-  const url = `https://coins.llama.fi/prices/current/${coinId}`;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Defillama API error: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  const price = data.coins?.[coinId]?.price;
-  if (!price && price !== 0) {
-    throw new Error(`Price not found for token: ${mappedIdentifier}`);
+`;
+var GET_RESPONSE_BY_REQUEST_ID = `
+query GetResponseByRequestId($requestId: String!) {
+  getResponses(filter: {requestId: {equalTo: $requestId}}) {
+    nodes {
+      id
+      commitment
+      responseMessage
+    }
   }
-  return price;
 }
-var ERC20Method = /* @__PURE__ */ ((ERC20Method2) => {
-  ERC20Method2["BALANCE_OF"] = "0x70a08231";
-  ERC20Method2["ALLOWANCE"] = "0xdd62ed3e";
-  return ERC20Method2;
-})(ERC20Method || {});
-async function getStorageSlot2(client, contractAddress, data) {
-  const traceCallClient = client.extend((client2) => ({
-    async traceCall(args) {
-      return client2.request({
-        // @ts-ignore
-        method: "debug_traceCall",
-        // @ts-ignore
-        params: [args, "latest", {}]
-      });
-    }
-  }));
-  const response = await traceCallClient.traceCall({
-    to: contractAddress,
-    data
-  });
-  const methodSignature = data.slice(0, 10);
-  const logs = response.structLogs;
-  for (let i = logs.length - 1; i >= 0; i--) {
-    const log = logs[i];
-    if (log.op === "SLOAD" && log.stack?.length >= 3) {
-      const sigHash = log.stack[0];
-      const slotHex = log.stack[log.stack.length - 1];
-      if (sigHash === methodSignature && slotHex.length === 66) {
-        return slotHex;
+`;
+var ORDER_STATUS = `
+query OrderStatus($commitment: String!) {
+  orderPlaceds(
+    filter: { commitment: { equalTo: $commitment } }
+  ) {
+    nodes {
+      id
+      user
+      sourceChain
+      destChain
+      commitment
+      deadline
+      nonce
+      fees
+      inputTokens
+      inputAmounts
+      inputValuesUSD
+      inputUSD
+      outputTokens
+      outputAmounts
+      outputBeneficiaries
+      calldata
+      status
+      createdAt
+      blockNumber
+      blockTimestamp
+      transactionHash
+      statusMetadata {
+        nodes {
+          status
+          chain
+          timestamp
+          blockNumber
+          transactionHash
+          filler
+        }
       }
     }
   }
-  throw new Error(`Storage slot not found for data: ${methodSignature}`);
-}
-function adjustFeeDecimals(feeInFeeToken, fromDecimals, toDecimals) {
-  if (fromDecimals === toDecimals) return feeInFeeToken;
-  if (fromDecimals < toDecimals) {
-    const scaleFactor = BigInt(10 ** (toDecimals - fromDecimals));
-    return feeInFeeToken * scaleFactor;
-  } else {
-    const scaleFactor = BigInt(10 ** (fromDecimals - toDecimals));
-    return (feeInFeeToken + scaleFactor - 1n) / scaleFactor;
+}`;
+var TOKEN_GATEWAY_ASSET_TELEPORTED_STATUS = `
+query TokenGatewayAssetTeleportedStatus($commitment: String!) {
+  tokenGatewayAssetTeleporteds(
+    filter: { commitment: { equalTo: $commitment } }
+  ) {
+    nodes {
+      id
+      from
+      to
+      sourceChain
+      destChain
+      commitment
+      amount
+      usdValue
+      assetId
+      redeem
+      status
+      createdAt
+      blockNumber
+      blockTimestamp
+      transactionHash
+      statusMetadata {
+        nodes {
+          status
+          chain
+          timestamp
+          blockNumber
+          transactionHash
+        }
+      }
+    }
   }
-}
+}`;
 function createQueryClient(config) {
   return new GraphQLClient(config.url);
 }
@@ -6155,7 +6168,7 @@ var IndexerClient = class {
       switch (status) {
         // request has been dispatched from source chain
         case RequestStatus.SOURCE: {
-          let sourceUpdate = await this.waitOrAbort({
+          const sourceUpdate = await this.waitOrAbort({
             signal,
             promise: () => this.queryStateMachineUpdateByHeight({
               statemachineId: request.source,
@@ -6197,7 +6210,7 @@ var IndexerClient = class {
         }
         // the request has been verified and aggregated on Hyperbridge
         case RequestStatus.HYPERBRIDGE_DELIVERED: {
-          let hyperbridgeFinalized = await this.waitOrAbort({
+          const hyperbridgeFinalized = await this.waitOrAbort({
             signal,
             promise: () => {
               const stateMachineId = this.config.hyperbridge.stateMachineId;
@@ -6214,17 +6227,36 @@ var IndexerClient = class {
             ...this.config.hyperbridge,
             hasher: "Keccak"
           });
-          const proof = await hyperbridge.queryProof(
-            { Requests: [postRequestCommitment(request).commitment] },
-            request.dest,
-            BigInt(hyperbridgeFinalized.height)
-          );
+          const safeFetchProof = async () => {
+            try {
+              const proof_hex = await hyperbridge.queryProof(
+                { Requests: [postRequestCommitment(request).commitment] },
+                request.dest,
+                BigInt(hyperbridgeFinalized.height)
+              );
+              return { data: proof_hex, error: null };
+            } catch (err) {
+              return { error: err, data: null };
+            }
+          };
+          const proof = await this.waitOrAbort({
+            signal,
+            promise: () => this.withRetry(safeFetchProof, {
+              backoffMs: 2e3,
+              maxRetries: 6
+              // <-- should fail after 2mins
+            })
+          });
+          if (proof.data === null) {
+            this.logger.error("Failed to fetch proof:", proof.error);
+            throw proof.error;
+          }
           const calldata = destChain.encode({
             kind: "PostRequest",
             proof: {
               stateMachine: this.config.hyperbridge.stateMachineId,
               consensusStateId: this.config.hyperbridge.consensusStateId,
-              proof,
+              proof: proof.data,
               height: BigInt(hyperbridgeFinalized.height)
             },
             requests: [request],
@@ -6313,7 +6345,7 @@ var IndexerClient = class {
   async *getRequestStatusStream(hash) {
     const controller = new AbortController();
     try {
-      let request = await this.waitOrAbort({
+      const request = await this.waitOrAbort({
         signal: controller.signal,
         promise: () => this.queryGetRequest(hash)
       });
@@ -6349,7 +6381,7 @@ var IndexerClient = class {
       switch (status) {
         // request has been dispatched from source chain
         case RequestStatus.SOURCE: {
-          let sourceUpdate = await this.waitOrAbort({
+          const sourceUpdate = await this.waitOrAbort({
             signal,
             promise: () => this.queryStateMachineUpdateByHeight({
               statemachineId: request.source,
@@ -6394,7 +6426,7 @@ var IndexerClient = class {
           if (request.source === this.config.hyperbridge.stateMachineId) {
             return;
           }
-          let hyperbridgeFinalized = await this.waitOrAbort({
+          const hyperbridgeFinalized = await this.waitOrAbort({
             signal,
             promise: () => this.queryStateMachineUpdateByHeight({
               statemachineId: this.config.hyperbridge.stateMachineId,
@@ -6645,7 +6677,7 @@ var IndexerClient = class {
               })
             });
           } else {
-            let timeout = await this.waitOrAbort({
+            const timeout = await this.waitOrAbort({
               signal,
               promise: async () => {
                 const req = await this.queryPostRequest(hash);
@@ -11321,7 +11353,7 @@ var IntentGateway = class {
     const postRequest = {
       source: order.destChain,
       dest: order.sourceChain,
-      body: constructRedeemEscrowRequestBody2(order, MOCK_ADDRESS2),
+      body: constructRedeemEscrowRequestBody(order, MOCK_ADDRESS),
       timeoutTimestamp: 0n,
       nonce: await this.source.getHostNonce(),
       from: this.source.config.getIntentGatewayAddress(order.destChain),
@@ -11345,23 +11377,23 @@ var IntentGateway = class {
     const fillOptions = {
       relayerFee: relayerFeeInDestFeeToken
     };
-    const totalEthValue = order.outputs.filter((output) => bytes32ToBytes202(output.token) === ADDRESS_ZERO2).reduce((sum, output) => sum + output.amount, 0n);
+    const totalEthValue = order.outputs.filter((output) => bytes32ToBytes20(output.token) === ADDRESS_ZERO).reduce((sum, output) => sum + output.amount, 0n);
     const intentGatewayAddress = this.source.config.getIntentGatewayAddress(order.destChain);
     const testValue = toHex(maxUint256 / 2n);
     const orderOverrides = await Promise.all(
       order.outputs.map(async (output) => {
-        const tokenAddress = bytes32ToBytes202(output.token);
-        if (tokenAddress === ADDRESS_ZERO2) {
+        const tokenAddress = bytes32ToBytes20(output.token);
+        if (tokenAddress === ADDRESS_ZERO) {
           return null;
         }
         try {
           const stateDiffs = [];
-          const balanceData = "0x70a08231" /* BALANCE_OF */ + bytes20ToBytes32(MOCK_ADDRESS2).slice(2);
-          const balanceSlot = await getStorageSlot2(this.dest.client, tokenAddress, balanceData);
+          const balanceData = "0x70a08231" /* BALANCE_OF */ + bytes20ToBytes32(MOCK_ADDRESS).slice(2);
+          const balanceSlot = await getStorageSlot(this.dest.client, tokenAddress, balanceData);
           stateDiffs.push({ slot: balanceSlot, value: testValue });
           try {
-            const allowanceData = "0xdd62ed3e" /* ALLOWANCE */ + bytes20ToBytes32(MOCK_ADDRESS2).slice(2) + bytes20ToBytes32(intentGatewayAddress).slice(2);
-            const allowanceSlot = await getStorageSlot2(
+            const allowanceData = "0xdd62ed3e" /* ALLOWANCE */ + bytes20ToBytes32(MOCK_ADDRESS).slice(2) + bytes20ToBytes32(intentGatewayAddress).slice(2);
+            const allowanceSlot = await getStorageSlot(
               this.dest.client,
               tokenAddress,
               allowanceData
@@ -11377,14 +11409,14 @@ var IntentGateway = class {
         }
       })
     ).then((results) => results.filter(Boolean));
-    const destFeeTokenBalanceData = "0x70a08231" /* BALANCE_OF */ + bytes20ToBytes32(MOCK_ADDRESS2).slice(2);
-    const destFeeTokenBalanceSlot = await getStorageSlot2(
+    const destFeeTokenBalanceData = "0x70a08231" /* BALANCE_OF */ + bytes20ToBytes32(MOCK_ADDRESS).slice(2);
+    const destFeeTokenBalanceSlot = await getStorageSlot(
       this.dest.client,
       destChainFeeTokenAddress,
       destFeeTokenBalanceData
     );
-    const destFeeTokenAllowanceData = "0xdd62ed3e" /* ALLOWANCE */ + bytes20ToBytes32(MOCK_ADDRESS2).slice(2) + bytes20ToBytes32(intentGatewayAddress).slice(2);
-    const destFeeTokenAllowanceSlot = await getStorageSlot2(
+    const destFeeTokenAllowanceData = "0xdd62ed3e" /* ALLOWANCE */ + bytes20ToBytes32(MOCK_ADDRESS).slice(2) + bytes20ToBytes32(intentGatewayAddress).slice(2);
+    const destFeeTokenAllowanceSlot = await getStorageSlot(
       this.dest.client,
       destChainFeeTokenAddress,
       destFeeTokenAllowanceData
@@ -11401,7 +11433,7 @@ var IntentGateway = class {
       // Mock address with ETH balance so that any chain estimation runs
       // even when the address doesn't hold any native token in that chain
       {
-        address: MOCK_ADDRESS2,
+        address: MOCK_ADDRESS,
         balance: maxUint256
       },
       ...orderOverrides.map((override) => ({
@@ -11414,7 +11446,7 @@ var IntentGateway = class {
       address: intentGatewayAddress,
       functionName: "fillOrder",
       args: [transformOrderForContract(order), fillOptions],
-      account: MOCK_ADDRESS2,
+      account: MOCK_ADDRESS,
       value: totalEthValue,
       stateOverride
     });
@@ -11458,8 +11490,8 @@ var IntentGateway = class {
     const v3Quoter = this.source.config.getUniswapV3QuoterAddress(chain);
     const v4Quoter = this.source.config.getUniswapV4QuoterAddress(chain);
     const wethAsset = this.source.config.getWrappedNativeAssetWithDecimals(chain).asset;
-    const tokenInForQuote = tokenIn === ADDRESS_ZERO2 ? wethAsset : tokenIn;
-    const tokenOutForQuote = tokenOut === ADDRESS_ZERO2 ? wethAsset : tokenOut;
+    const tokenInForQuote = tokenIn === ADDRESS_ZERO ? wethAsset : tokenIn;
+    const tokenOutForQuote = tokenOut === ADDRESS_ZERO ? wethAsset : tokenOut;
     try {
       const v2PairExists = await destClient.readContract({
         address: v2Factory,
@@ -11467,7 +11499,7 @@ var IntentGateway = class {
         functionName: "getPair",
         args: [tokenInForQuote, tokenOutForQuote]
       });
-      if (v2PairExists !== ADDRESS_ZERO2) {
+      if (v2PairExists !== ADDRESS_ZERO) {
         const v2AmountIn = await destClient.readContract({
           address: v2Router,
           abi: uniswapRouterV2_default.ABI,
@@ -11488,7 +11520,7 @@ var IntentGateway = class {
           functionName: "getPool",
           args: [tokenInForQuote, tokenOutForQuote, fee]
         });
-        if (pool !== ADDRESS_ZERO2) {
+        if (pool !== ADDRESS_ZERO) {
           const liquidity = await destClient.readContract({
             address: pool,
             abi: uniswapV3Pool_default.ABI,
@@ -11532,7 +11564,7 @@ var IntentGateway = class {
           currency1,
           fee,
           tickSpacing: this.getTickSpacing(fee),
-          hooks: ADDRESS_ZERO2
+          hooks: ADDRESS_ZERO
           // No hooks
         };
         const quoteResult = (await destClient.simulateContract({
@@ -11622,8 +11654,8 @@ var IntentGateway = class {
     const v3Quoter = this.source.config.getUniswapV3QuoterAddress(chain);
     const v4Quoter = this.source.config.getUniswapV4QuoterAddress(chain);
     const wethAsset = this.source.config.getWrappedNativeAssetWithDecimals(chain).asset;
-    const tokenInForQuote = tokenIn === ADDRESS_ZERO2 ? wethAsset : tokenIn;
-    const tokenOutForQuote = tokenOut === ADDRESS_ZERO2 ? wethAsset : tokenOut;
+    const tokenInForQuote = tokenIn === ADDRESS_ZERO ? wethAsset : tokenIn;
+    const tokenOutForQuote = tokenOut === ADDRESS_ZERO ? wethAsset : tokenOut;
     try {
       const v2PairExists = await destClient.readContract({
         address: v2Factory,
@@ -11631,7 +11663,7 @@ var IntentGateway = class {
         functionName: "getPair",
         args: [tokenInForQuote, tokenOutForQuote]
       });
-      if (v2PairExists !== ADDRESS_ZERO2) {
+      if (v2PairExists !== ADDRESS_ZERO) {
         const v2AmountOut = await destClient.readContract({
           address: v2Router,
           abi: uniswapRouterV2_default.ABI,
@@ -11652,7 +11684,7 @@ var IntentGateway = class {
           functionName: "getPool",
           args: [tokenInForQuote, tokenOutForQuote, fee]
         });
-        if (pool !== ADDRESS_ZERO2) {
+        if (pool !== ADDRESS_ZERO) {
           const liquidity = await destClient.readContract({
             address: pool,
             abi: uniswapV3Pool_default.ABI,
@@ -11696,7 +11728,7 @@ var IntentGateway = class {
           currency1,
           fee,
           tickSpacing: this.getTickSpacing(fee),
-          hooks: ADDRESS_ZERO2
+          hooks: ADDRESS_ZERO
           // No hooks
         };
         const quoteResult = (await destClient.simulateContract({
@@ -11780,9 +11812,9 @@ var IntentGateway = class {
       throw new Error("Chain native currency information not available");
     }
     const gasCostInToken = Number(gasCostInWei) / Math.pow(10, nativeToken.decimals);
-    const tokenPriceUsd = await fetchTokenUsdPrice2(nativeToken.symbol);
+    const tokenPriceUsd = await fetchTokenUsdPrice(nativeToken.symbol);
     const gasCostUsd = gasCostInToken * tokenPriceUsd;
-    const feeTokenPriceUsd = await fetchTokenUsdPrice2("DAI");
+    const feeTokenPriceUsd = await fetchTokenUsdPrice("DAI");
     const gasCostInFeeToken = gasCostUsd / feeTokenPriceUsd;
     return BigInt(Math.floor(gasCostInFeeToken * Math.pow(10, targetDecimals)));
   }
@@ -12150,6 +12182,6 @@ async function teleportDot(param_) {
   return stream;
 }
 
-export { ADDRESS_ZERO2 as ADDRESS_ZERO, AbortSignalInternal, ChainConfigService, Chains, DEFAULT_ADDRESS, DUMMY_PRIVATE_KEY, ERC20Method, EvmChain, HyperClientStatus, IndexerClient, IntentGateway, OrderStatus, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, STATE_COMMITMENTS_SLOT, SubstrateChain, TeleportStatus, TimeoutStatus, WrappedNativeDecimals, __test, addresses, adjustFeeDecimals, assets, bytes20ToBytes32, bytes32ToBytes202 as bytes32ToBytes20, chainIds, consensusStateIds, constructRedeemEscrowRequestBody2 as constructRedeemEscrowRequestBody, convertStateMachineIdToEnum, createQueryClient, createRpcUrls, encodeISMPMessage, estimateGasForPost, fetchTokenUsdPrice2 as fetchTokenUsdPrice, generateRootWithProof, getChain, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot2 as getStorageSlot, hexToString2 as hexToString, orderCommitment2 as orderCommitment, postRequestCommitment, queryGetRequest, queryPostRequest, teleport, teleportDot, viemChains };
+export { ADDRESS_ZERO, ChainConfigService, Chains, DEFAULT_ADDRESS, DUMMY_PRIVATE_KEY, ERC20Method, EvmChain, HyperClientStatus, IndexerClient, IntentGateway, OrderStatus, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, STATE_COMMITMENTS_SLOT, SubstrateChain, TeleportStatus, TimeoutStatus, WrappedNativeDecimals, __test, addresses, adjustFeeDecimals, assets, bytes20ToBytes32, bytes32ToBytes20, chainIds, consensusStateIds, constructRedeemEscrowRequestBody, convertStateMachineIdToEnum, createQueryClient, createRpcUrls, encodeISMPMessage, estimateGasForPost, fetchTokenUsdPrice, generateRootWithProof, getChain, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, hexToString, orderCommitment, postRequestCommitment, queryGetRequest, queryPostRequest, teleport, teleportDot, viemChains };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map