@hyperbridge/sdk 1.2.2 → 1.3.0-canary-000001

package/dist/browser/index.js

@@ -1,14 +1,14 @@
 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';
 
@@ -279,234 +279,6 @@ var init_web = __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",
@@ -554,16 +326,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 = [
@@ -3590,1985 +3352,2243 @@ 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_web(), web_exports));
+    await wasm2.default();
+    return wasm2;
   }
-  get config() {
-    return this.chainConfigService;
+  if (isNode) {
+    const wasm2 = await Promise.resolve().then(() => (init_web(), web_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;
+  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.
+   */
+  source: StateMachine,
+  /*
+   * The destination state machine of this request.
+   */
+  dest: StateMachine,
+  /*
+   * The nonce of this request on the source chain
+   */
+  nonce: u64,
+  /*
+   * Module identifier of the sending module
+   */
+  from: Vector(u8),
+  /*
+   * Module identifier of the receiving module
+   */
+  to: Vector(u8),
+  /*
+   * Timestamp which this request expires in seconds.
+   */
+  timeoutTimestamp: u64,
+  /*
+   * Encoded request body
+   */
+  body: Vector(u8)
+});
+var PostResponse = Struct({
+  /*
+   * The request that triggered this response.
+   */
+  post: PostRequest,
+  /*
+   * The response message.
+   */
+  response: Vector(u8),
+  /*
+   * Timestamp at which this response expires in seconds.
+   */
+  timeoutTimestamp: u64
+});
+var GetRequest = Struct({
+  /*
+   * The source state machine of this request.
+   */
+  source: StateMachine,
+  /*
+   * The destination state machine of this request.
+   */
+  dest: StateMachine,
+  /*
+   * The nonce of this request on the source chain
+   */
+  nonce: u64,
+  /*
+   * Module identifier of the sending module
+   */
+  from: Vector(u8),
+  /*
+   * Raw Storage keys that would be used to fetch the values from the counterparty
+   * For deriving storage keys for ink contract fields follow the guide in the link below
+   * `<https://use.ink/datastructures/storage-in-metadata#a-full-example>`
+   * Substrate Keys
+   */
+  keys: Vector(Vector(u8)),
+  /*
+   * Some application-specific metadata relating to this request
+   */
+  context: Vector(u8),
+  /*
+   * Host timestamp at which this request expires in seconds
+   */
+  timeoutTimestamp: u64
+});
+var StorageValue = Struct({
+  /*
+   * The request storage keys
+   */
+  key: Vector(u8),
+  /*
+   * The verified value
+   */
+  value: Option(Vector(u8))
+});
+var GetResponse = Struct({
+  /*
+   * The Get request that triggered this response.
+   */
+  get: GetRequest,
+  /*
+   * Values derived from the state proof
+   */
+  values: Vector(StorageValue)
+});
+var Request2 = Enum({
+  /*
+   * A post request allows a module on a state machine to send arbitrary bytes to another module
+   * living in another state machine.
+   */
+  Post: PostRequest,
+  /*
+   * A get request allows a module on a state machine to read the storage of another module
+   * living in another state machine.
+   */
+  Get: GetRequest
+});
+var Response2 = Enum({
+  /*
+   * The response to a POST request
+   */
+  Post: PostResponse,
+  /*
+   * The response to a GET request
+   */
+  Get: GetResponse
+});
+var RequestMessage = Struct({
+  /*
+   * Requests from source chain
+   */
+  requests: Vector(PostRequest),
+  /*
+   * Membership batch proof for these requests
+   */
+  proof: Proof,
+  /*
+   * Signer information. Ideally should be their account identifier
+   */
+  signer: Vector(u8)
+});
+var RequestResponse = Enum({
+  /*
+   * A set of requests
+   */
+  Request: Vector(Request2),
+  /*
+   * A set of responses
+   */
+  Response: Vector(Response2)
+});
+var ResponseMessage = Struct({
+  /*
+   * A set of either POST requests or responses to be handled
+   */
+  datagram: Vector(RequestResponse),
+  /*
+   * Membership batch proof for these requests/responses
+   */
+  proof: Proof,
+  /*
+   * Signer information. Ideally should be their account identifier
+   */
+  signer: Vector(u8)
+});
+var TimeoutMessage = Enum({
+  /*
+   * A non memership proof for POST requests
+   */
+  Post: Struct({
+    /*
+     * Timed out requests
+     */
+    requests: Vector(Request2),
+    /*
+     * Membership batch proof for these requests
+     */
+    proof: Proof
+  }),
+  /*
+   * A non memership proof for POST responses
+   */
+  PostResponse: Struct({
+    /*
+     * Timed out responses
+     */
+    responses: Vector(Response2),
+    /*
+     * Membership batch proof for these responses
+     */
+    proof: Proof
+  }),
+  /*
+   * There are no proofs for Get timeouts
+   */
+  Get: Struct({
+    /*
+     * Timed out requests
+     */
+    requests: Vector(Request2)
+  })
+});
+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.`);
   }
-  /**
-   * 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,
+  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" },
           {
-            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,
+            name: "outputs",
+            type: "tuple[]",
+            components: [
+              { name: "token", type: "bytes32" },
+              { name: "amount", type: "uint256" },
+              { name: "beneficiary", type: "bytes32" }
+            ]
+          },
           {
-            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
-          }
+            name: "inputs",
+            type: "tuple[]",
+            components: [
+              { name: "token", type: "bytes32" },
+              { name: "amount", type: "uint256" }
+            ]
+          },
+          { name: "callData", type: "bytes" }
         ]
-      });
-      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
+      }
+    ],
+    [
+      {
+        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: leafIndexAndPos?.leafIndex,
+          index,
           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,
+        }
+      ]
+    }
+  ];
+  const gas_fee = await params.sourceClient.estimateContractGas({
+    address: hostParams.handler,
+    abi: handler_default.ABI,
+    functionName: "handlePostRequests",
+    args: call_data,
+    stateOverride: [
+      {
+        address: params.hostAddress,
+        stateDiff: [
           {
-            proof,
-            responses
+            slot: overlayRootSlot,
+            value: root
           }
         ]
-      });
-      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;
+      }
+    ]
+  });
+  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();
 };
-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 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;
+  }
 }
-function deriveMapKey(key, slot) {
-  const slotBytes = pad(`0x${slot.toString(16)}`, { size: 32 });
-  const combined = new Uint8Array([...key, ...toBytes(slotBytes)]);
-  return keccak256(combined);
+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;
+    }
+  }
 }
-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 });
+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;
 }
-function getStateCommitmentSlot(stateMachineId, height) {
-  const firstLevelSlot = deriveFirstLevelSlot(stateMachineId, STATE_COMMITMENTS_SLOT);
-  return deriveSecondLevelSlot(height, firstLevelSlot);
+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;
 }
-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);
+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 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);
+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 SubstrateChain = class {
-  constructor(params) {
-    this.params = params;
+
+// src/utils/exceptions.ts
+var AbortSignalInternal = class _AbortSignalInternal extends Error {
+  constructor(message) {
+    super();
+    this.name = "Hyperbridge/SDK/AbortSignalInternal";
+    this.message = message;
   }
-  /*
-   * api: The Polkadot API instance for the Substrate chain.
-   */
-  api;
-  /*
-   * connect: Connects to the Substrate chain using the provided WebSocket URL.
-   */
-  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
-    });
+  static isError(error) {
+    return error instanceof _AbortSignalInternal;
   }
-  /**
-   * Disconnects the Substrate chain connection.
-   */
-  async disconnect() {
-    if (this.api) {
-      await this.api.disconnect();
-      this.api = void 0;
-    }
+};
+var ExpectedError = class _ExpectedError extends Error {
+  constructor(message) {
+    super();
+    this.name = "Hyperbridge/SDK/ExpectedError";
+    this.message = message;
   }
-  /**
-   * 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
-   */
-  requestReceiptKey(key) {
-    const prefix = new TextEncoder().encode("RequestReceipts");
-    const keyBytes = hexToBytes(key);
-    return bytesToHex(new Uint8Array([...prefix, ...keyBytes]));
+  static isError(error) {
+    return error instanceof _ExpectedError;
   }
-  /**
-   * 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
-   */
-  requestCommitmentKey(key) {
-    const prefix = new TextEncoder().encode("RequestCommitments");
-    const keyBytes = hexToBytes(key);
-    return bytesToHex(new Uint8Array([...prefix, ...keyBytes]));
+};
+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 */]: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24"
+  },
+  UniswapV2Factory: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0x12e036669DA18F4A2777853d6e2136b32AceEC86",
+    ["EVM-10200" /* GNOSIS_CHIADO */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-11155111" /* SEPOLIA */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-1" /* MAINNET */]: "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
+    ["EVM-56" /* BSC_MAINNET */]: "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6"
+  },
+  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"
   }
-  /**
-   * 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.
-   */
-  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;
+};
+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);
   }
-  /**
-   * 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;
+  getChainConfig(chain) {
+    return {
+      chainId: chainIds[chain],
+      rpcUrl: this.rpcUrls[chain],
+      intentGatewayAddress: addresses.IntentGateway[chain]
+    };
   }
-  /**
-   * 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);
+  getIntentGatewayAddress(chain) {
+    return addresses.IntentGateway[chain];
   }
-  /**
-   * 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);
-    }
-    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}`);
+  getHostAddress(chain) {
+    return addresses.Host[chain];
   }
-  /**
-   * 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);
-    });
+  getWrappedNativeAssetWithDecimals(chain) {
+    return {
+      asset: assets[chain].WETH,
+      decimals: WrappedNativeDecimals[chain]
+    };
   }
-  /**
-   * 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 toHex(encoded);
+  getDaiAsset(chain) {
+    return assets[chain].DAI;
   }
-  /**
-   * 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());
+  getUsdtAsset(chain) {
+    return assets[chain].USDT;
   }
-  /**
-   * 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());
+  getUsdcAsset(chain) {
+    return assets[chain].USDC;
   }
-  /**
-   * 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());
+  getChainId(chain) {
+    return chainIds[chain];
   }
-  /**
-   * 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]));
+  getConsensusStateId(chain) {
+    return toHex(consensusStateIds[chain]);
   }
-  /**
-   * 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`);
+  getHyperbridgeChainId() {
+    return chainIds["KUSAMA-4009" /* HYPERBRIDGE_GARGANTUA */];
   }
-};
-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));
+  getRpcUrl(chain) {
+    return this.rpcUrls[chain];
   }
-  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 });
+  getUniswapRouterV2Address(chain) {
+    return addresses.UniswapRouter02[chain];
   }
-}
-
-// 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;
+  getUniswapV2FactoryAddress(chain) {
+    return addresses.UniswapV2Factory[chain];
   }
-  if (isSubstrateChain(chainConfig.stateMachineId)) {
-    const config = chainConfig;
-    const substrateChain = new SubstrateChain({
-      ws: config.wsUrl,
-      hasher: config.hasher
-    });
-    await substrateChain.connect();
-    return substrateChain;
+  getBatchExecutorAddress(chain) {
+    return addresses.BatchExecutor[chain];
   }
-  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);
+  getUniversalRouterAddress(chain) {
+    return addresses.UniversalRouter[chain];
   }
-  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;
+  getUniswapV3RouterAddress(chain) {
+    return addresses.UniswapV3Router[chain];
   }
-  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);
+  getUniswapV3FactoryAddress(chain) {
+    return addresses.UniswapV3Factory[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);
+  getUniswapV3QuoterAddress(chain) {
+    return addresses.UniswapV3Quoter[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;
+  getUniswapV4PoolManagerAddress(chain) {
+    return addresses.UniswapV4PoolManager[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]);
-      }
-    }
+  getUniswapV4QuoterAddress(chain) {
+    return addresses.UniswapV4Quoter[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: 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");
+};
+
+// 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();
   }
-  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_web(), web_exports));
-    await wasm2.default();
-    return wasm2;
+  publicClient;
+  chainConfigService;
+  // Expose minimal getters for external helpers/classes
+  get client() {
+    return this.publicClient;
   }
-  if (isNode) {
-    const wasm2 = await Promise.resolve().then(() => (init_web(), web_exports));
-    return wasm2;
+  get host() {
+    return this.params.host;
+  }
+  get config() {
+    return this.chainConfigService;
   }
-  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.
-   */
-  source: StateMachine,
-  /*
-   * The destination state machine of this request.
-   */
-  dest: StateMachine,
-  /*
-   * The nonce of this request on the source chain
-   */
-  nonce: u64,
-  /*
-   * Module identifier of the sending module
-   */
-  from: Vector(u8),
-  /*
-   * Module identifier of the receiving module
-   */
-  to: Vector(u8),
-  /*
-   * Timestamp which this request expires in seconds.
-   */
-  timeoutTimestamp: u64,
-  /*
-   * Encoded request body
-   */
-  body: Vector(u8)
-});
-var PostResponse = Struct({
-  /*
-   * The request that triggered this response.
-   */
-  post: PostRequest,
-  /*
-   * The response message.
-   */
-  response: Vector(u8),
-  /*
-   * Timestamp at which this response expires in seconds.
-   */
-  timeoutTimestamp: u64
-});
-var GetRequest = Struct({
-  /*
-   * The source state machine of this request.
-   */
-  source: StateMachine,
-  /*
-   * The destination state machine of this request.
-   */
-  dest: StateMachine,
-  /*
-   * The nonce of this request on the source chain
-   */
-  nonce: u64,
-  /*
-   * Module identifier of the sending module
-   */
-  from: Vector(u8),
-  /*
-   * Raw Storage keys that would be used to fetch the values from the counterparty
-   * For deriving storage keys for ink contract fields follow the guide in the link below
-   * `<https://use.ink/datastructures/storage-in-metadata#a-full-example>`
-   * Substrate Keys
-   */
-  keys: Vector(Vector(u8)),
-  /*
-   * Some application-specific metadata relating to this request
+   * Derives the key for the request receipt.
+   * @param {HexString} commitment - The commitment to derive the key from.
+   * @returns {HexString} The derived key.
    */
-  context: Vector(u8),
-  /*
-   * Host timestamp at which this request expires in seconds
+  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.
    */
-  timeoutTimestamp: u64
-});
-var StorageValue = Struct({
-  /*
-   * The request storage keys
+  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.
    */
-  key: Vector(u8),
-  /*
-   * The verified value
+  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.
    */
-  value: Option(Vector(u8))
-});
-var GetResponse = Struct({
-  /*
-   * The Get request that triggered this response.
+  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.
    */
-  get: GetRequest,
-  /*
-   * Values derived from the state proof
+  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.
    */
-  values: Vector(StorageValue)
-});
-var Request2 = Enum({
-  /*
-   * A post request allows a module on a state machine to send arbitrary bytes to another module
-   * living in another state machine.
+  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.
    */
-  Post: PostRequest,
-  /*
-   * A get request allows a module on a state machine to read the storage of another module
-   * living in another state machine.
+  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.
    */
-  Get: GetRequest
-});
-var Response2 = Enum({
-  /*
-   * The response to a POST request
+  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.
    */
-  Post: PostResponse,
-  /*
-   * The response to a GET request
+  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
    */
-  Get: GetResponse
-});
-var RequestMessage = Struct({
-  /*
-   * Requests from source chain
+  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 and the generated calldata
    */
-  requests: Vector(PostRequest),
-  /*
-   * Membership batch proof for these requests
+  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 formattedRequest = {
+      ...request,
+      source: toHex(request.source),
+      dest: toHex(request.dest)
+    };
+    const contractArgs = [
+      this.params.host,
+      {
+        proof: postParams,
+        requests: [
+          {
+            request: formattedRequest,
+            index,
+            kIndex
+          }
+        ]
+      }
+    ];
+    const postRequestCalldata = encodeFunctionData({
+      abi: handler_default.ABI,
+      functionName: "handlePostRequests",
+      args: contractArgs
+    });
+    const gas = await this.publicClient.estimateContractGas({
+      address: hostParams.handler,
+      abi: handler_default.ABI,
+      functionName: "handlePostRequests",
+      args: contractArgs,
+      stateOverride: [
+        {
+          address: this.params.host,
+          stateDiff: [
+            {
+              slot: overlayRootSlot,
+              value: root
+            }
+          ]
+        }
+      ]
+    });
+    return { gas, postRequestCalldata };
+  }
+  /**
+   * 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
    */
-  proof: Proof,
-  /*
-   * Signer information. Ideally should be their account identifier
+  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
    */
-  signer: Vector(u8)
-});
-var RequestResponse = Enum({
+  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;
+  }
   /*
-   * A set of requests
+   * api: The Polkadot API instance for the Substrate chain.
    */
-  Request: Vector(Request2),
+  api;
   /*
-   * A set of responses
+   * connect: Connects to the Substrate chain using the provided WebSocket URL.
    */
-  Response: Vector(Response2)
-});
-var ResponseMessage = Struct({
-  /*
-   * A set of either POST requests or responses to be handled
+  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.
    */
-  datagram: Vector(RequestResponse),
-  /*
-   * Membership batch proof for these requests/responses
+  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
    */
-  proof: Proof,
-  /*
-   * Signer information. Ideally should be their account identifier
+  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
    */
-  signer: Vector(u8)
-});
-var TimeoutMessage = Enum({
-  /*
-   * A non memership proof for POST requests
+  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.
    */
-  Post: Struct({
-    /*
-     * Timed out requests
-     */
-    requests: Vector(Request2),
-    /*
-     * Membership batch proof for these requests
-     */
-    proof: Proof
-  }),
-  /*
-   * A non memership proof for POST responses
+  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.
    */
-  PostResponse: Struct({
-    /*
-     * Timed out responses
-     */
-    responses: Vector(Response2),
-    /*
-     * Membership batch proof for these responses
-     */
-    proof: Proof
-  }),
-  /*
-   * There are no proofs for Get timeouts
+  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.
    */
-  Get: Struct({
-    /*
-     * Timed out requests
-     */
-    requests: Vector(Request2)
-  })
-});
-var Message = Enum({
-  /*
-   * A consensus update message
+  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.
    */
-  ConsensusMessage,
-  /*
-   * A fraud proof message
+  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 ExpectedError(`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.
    */
-  FraudProofMessage,
-  /*
-   * A request message
+  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.
    */
-  RequestMessage,
-  /*
-   * A response message
+  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.
    */
-  ResponseMessage,
-  /*
-   * A request timeout message
+  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.
    */
-  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 stateMachineUpdateTime(stateMachineHeight) {
+    if (!this.api) throw new Error("API not initialized");
+    const updateTime = await this.api.query.ismp.stateMachineUpdateTime(stateMachineHeight);
+    return BigInt(updateTime.toString());
   }
-}
-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"`
-    );
+  /**
+   * 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]));
   }
-  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.`);
+  /**
+   * 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;
       }
-      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 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
-      }
-    ]
-  );
-  return keccak256(encodedOrder);
-}
-function bytes32ToBytes202(bytes32Address) {
-  if (bytes32Address === ADDRESS_ZERO2) {
-    return ADDRESS_ZERO2;
+    throw new Error(`${name} not found in runtime`);
   }
-  const bytes = hexToBytes(bytes32Address);
-  const addressBytes = bytes.slice(12);
-  return bytesToHex(addressBytes);
+};
+function requestCommitmentStorageKey(key) {
+  const prefix = new TextEncoder().encode("RequestCommitments");
+  const keyBytes = hexToBytes(key);
+  return Array.from(new Uint8Array([...prefix, ...keyBytes]));
 }
-function bytes20ToBytes32(bytes20Address) {
-  return `0x${bytes20Address.slice(2).padStart(64, "0")}`;
+function responseCommitmentStorageKey(key) {
+  const prefix = new TextEncoder().encode("ResponseCommitments");
+  const keyBytes = hexToBytes(key);
+  return Array.from(new Uint8Array([...prefix, ...keyBytes]));
 }
-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);
+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 new TextDecoder().decode(bytes);
+  return { tag, value };
 }
-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));
+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
     }
-  }
-  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 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
-          }
-        ]
-      }
-    ],
-    stateOverride: [
-      {
-        address: params.hostAddress,
-        stateDiff: [
-          {
-            slot: overlayRootSlot,
-            value: root
+            signer: Array.from(hexToBytes(message2.signer))
           }
-        ]
-      }
-    ]
-  });
-  return gas;
-}
-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" }
-            ]
+        }
+      ]);
+    }).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))
+              }
+            }
           }
-        ]
-      }
-    ],
-    [requestBody]
-  );
-  return concatHex([requestKind, encodedRequestBody]);
+        }
+      ]);
+    }).exhaustive();
+  } catch (error) {
+    throw new Error("Failed to encode ISMP message", { cause: error });
+  }
 }
-var dateStringtoTimestamp = (date) => {
-  if (!date.endsWith("Z")) {
-    date = `${date}Z`;
+
+// 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;
   }
-  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;
+  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}`);
 }
-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;
+
+// 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
+        }
+      }
     }
   }
 }
-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 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
+      }
+    }
   }
-  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);
 }
@@ -6204,7 +6224,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,
@@ -6246,7 +6266,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;
@@ -6263,17 +6283,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],
@@ -6362,7 +6401,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)
       });
@@ -6398,7 +6437,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,
@@ -6443,7 +6482,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,
@@ -6694,7 +6733,7 @@ var IndexerClient = class {
               })
             });
           } else {
-            let timeout = await this.waitOrAbort({
+            const timeout = await this.waitOrAbort({
               signal,
               promise: async () => {
                 const req = await this.queryPostRequest(hash);
@@ -11364,21 +11403,21 @@ var IntentGateway = class {
    * protocol fees, and swap operations.
    *
    * @param order - The order to estimate fill costs for
-   * @returns The estimated total cost in the source chain's fee token
+   * @returns An object containing the estimated cost in both fee token and native token, plus the post request calldata
    */
   async estimateFillOrder(order) {
     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),
       to: this.source.config.getIntentGatewayAddress(order.sourceChain)
     };
-    const { decimals: sourceChainFeeTokenDecimals } = await this.source.getFeeTokenWithDecimals();
+    const { decimals: sourceChainFeeTokenDecimals, address: sourceChainFeeTokenAddress } = await this.source.getFeeTokenWithDecimals();
     const { address: destChainFeeTokenAddress, decimals: destChainFeeTokenDecimals } = await this.dest.getFeeTokenWithDecimals();
-    const postGasEstimate = await this.source.estimateGas(postRequest);
+    const { gas: postGasEstimate, postRequestCalldata } = await this.source.estimateGas(postRequest);
     const postGasEstimateInSourceFeeToken = await this.convertGasToFeeToken(
       postGasEstimate,
       this.source.client,
@@ -11394,23 +11433,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
@@ -11426,31 +11465,11 @@ var IntentGateway = class {
         }
       })
     ).then((results) => results.filter(Boolean));
-    const destFeeTokenBalanceData = "0x70a08231" /* BALANCE_OF */ + bytes20ToBytes32(MOCK_ADDRESS2).slice(2);
-    const destFeeTokenBalanceSlot = await getStorageSlot2(
-      this.dest.client,
-      destChainFeeTokenAddress,
-      destFeeTokenBalanceData
-    );
-    const destFeeTokenAllowanceData = "0xdd62ed3e" /* ALLOWANCE */ + bytes20ToBytes32(MOCK_ADDRESS2).slice(2) + bytes20ToBytes32(intentGatewayAddress).slice(2);
-    const destFeeTokenAllowanceSlot = await getStorageSlot2(
-      this.dest.client,
-      destChainFeeTokenAddress,
-      destFeeTokenAllowanceData
-    );
-    const feeTokenStateDiffs = [
-      { slot: destFeeTokenBalanceSlot, value: testValue },
-      { slot: destFeeTokenAllowanceSlot, value: testValue }
-    ];
-    orderOverrides.push({
-      address: destChainFeeTokenAddress,
-      stateDiff: feeTokenStateDiffs
-    });
-    const stateOverride = [
+    let stateOverrides = [
       // 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) => ({
@@ -11458,15 +11477,52 @@ var IntentGateway = class {
         stateDiff: override.stateDiff
       }))
     ];
-    const destChainFillGas = await this.dest.client.estimateContractGas({
-      abi: IntentGateway_default.ABI,
-      address: intentGatewayAddress,
-      functionName: "fillOrder",
-      args: [transformOrderForContract(order), fillOptions],
-      account: MOCK_ADDRESS2,
-      value: totalEthValue,
-      stateOverride
-    });
+    let destChainFillGas = 0n;
+    try {
+      const protocolFeeInNativeToken = await this.quoteNative(postRequest, relayerFeeInDestFeeToken);
+      destChainFillGas = await this.dest.client.estimateContractGas({
+        abi: IntentGateway_default.ABI,
+        address: intentGatewayAddress,
+        functionName: "fillOrder",
+        args: [transformOrderForContract(order), fillOptions],
+        account: MOCK_ADDRESS,
+        value: totalEthValue + protocolFeeInNativeToken,
+        stateOverride: stateOverrides
+      });
+    } catch {
+      console.warn(
+        `Could not estimate gas for fill order with native token as fees for chain ${order.destChain}, now trying with fee token as fees`
+      );
+      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_ADDRESS).slice(2) + bytes20ToBytes32(intentGatewayAddress).slice(2);
+      const destFeeTokenAllowanceSlot = await getStorageSlot(
+        this.dest.client,
+        destChainFeeTokenAddress,
+        destFeeTokenAllowanceData
+      );
+      const feeTokenStateDiffs = [
+        { slot: destFeeTokenBalanceSlot, value: testValue },
+        { slot: destFeeTokenAllowanceSlot, value: testValue }
+      ];
+      stateOverrides.push({
+        address: destChainFeeTokenAddress,
+        stateDiff: feeTokenStateDiffs
+      });
+      destChainFillGas = await this.dest.client.estimateContractGas({
+        abi: IntentGateway_default.ABI,
+        address: intentGatewayAddress,
+        functionName: "fillOrder",
+        args: [transformOrderForContract(order), fillOptions],
+        account: MOCK_ADDRESS,
+        value: totalEthValue,
+        stateOverride: stateOverrides
+      });
+    }
     const fillGasInSourceFeeToken = await this.convertGasToFeeToken(
       destChainFillGas,
       this.dest.client,
@@ -11481,17 +11537,88 @@ var IntentGateway = class {
     const totalEstimate = fillGasInSourceFeeToken + protocolFeeInSourceFeeToken + relayerFeeInSourceFeeToken;
     const SWAP_OPERATIONS_BPS = 2500n;
     const swapOperationsInFeeToken = totalEstimate * SWAP_OPERATIONS_BPS / 10000n;
-    return totalEstimate + swapOperationsInFeeToken;
+    const totalFeeTokenAmount = totalEstimate + swapOperationsInFeeToken;
+    const totalNativeTokenAmount = await this.convertFeeTokenToNative(
+      totalFeeTokenAmount,
+      this.source.client,
+      sourceChainFeeTokenDecimals
+    );
+    return {
+      feeTokenAmount: totalFeeTokenAmount,
+      nativeTokenAmount: totalNativeTokenAmount,
+      postRequestCalldata
+    };
+  }
+  /**
+   * Converts fee token amounts back to the equivalent amount in native token.
+   * Uses USD pricing to convert between fee token amounts and native token costs.
+   *
+   * @param feeTokenAmount - The amount in fee token (DAI)
+   * @param publicClient - The client for the chain to get native token info
+   * @param feeTokenDecimals - The decimal places of the fee token
+   * @returns The fee token amount converted to native token amount
+   * @private
+   */
+  async convertFeeTokenToNative(feeTokenAmount, publicClient, feeTokenDecimals) {
+    const nativeToken = publicClient.chain?.nativeCurrency;
+    if (!nativeToken?.symbol || !nativeToken?.decimals) {
+      throw new Error("Chain native currency information not available");
+    }
+    const feeTokenAmountNumber = Number(feeTokenAmount) / Math.pow(10, feeTokenDecimals);
+    const nativeTokenPriceUsd = await fetchTokenUsdPrice(nativeToken.symbol);
+    const totalCostInNativeToken = feeTokenAmountNumber / nativeTokenPriceUsd;
+    return BigInt(Math.floor(totalCostInNativeToken * Math.pow(10, nativeToken.decimals)));
+  }
+  /**
+   * Converts gas costs to the equivalent amount in the fee token (DAI).
+   * Uses USD pricing to convert between native token gas costs and fee token amounts.
+   *
+   * @param gasEstimate - The estimated gas units
+   * @param publicClient - The client for the chain to get gas prices
+   * @param targetDecimals - The decimal places of the target fee token
+   * @returns The gas cost converted to fee token amount
+   * @private
+   */
+  async convertGasToFeeToken(gasEstimate, publicClient, targetDecimals) {
+    const gasPrice = await publicClient.getGasPrice();
+    const gasCostInWei = gasEstimate * gasPrice;
+    const nativeToken = publicClient.chain?.nativeCurrency;
+    if (!nativeToken?.symbol || !nativeToken?.decimals) {
+      throw new Error("Chain native currency information not available");
+    }
+    const gasCostInToken = Number(gasCostInWei) / Math.pow(10, nativeToken.decimals);
+    const tokenPriceUsd = await fetchTokenUsdPrice(nativeToken.symbol);
+    const gasCostUsd = gasCostInToken * tokenPriceUsd;
+    const feeTokenPriceUsd = await fetchTokenUsdPrice("DAI");
+    const gasCostInFeeToken = gasCostUsd / feeTokenPriceUsd;
+    return BigInt(Math.floor(gasCostInFeeToken * Math.pow(10, targetDecimals)));
+  }
+  async quoteNative(postRequest, fee) {
+    const dispatchPost = {
+      dest: toHex(postRequest.dest),
+      to: postRequest.to,
+      body: postRequest.body,
+      timeout: postRequest.timeoutTimestamp,
+      fee,
+      payer: postRequest.from
+    };
+    const quoteNative = await this.dest.client.readContract({
+      address: this.dest.config.getIntentGatewayAddress(postRequest.dest),
+      abi: IntentGateway_default.ABI,
+      functionName: "quoteNative",
+      args: [dispatchPost]
+    });
+    return quoteNative;
   }
   /**
-   * Finds the best Uniswap protocol (V2 or V3) for swapping tokens given a desired output amount.
+   * Finds the best Uniswap protocol (V2, V3, or V4) for swapping tokens given a desired output amount.
    * Compares liquidity and pricing across different protocols and fee tiers.
    *
    * @param chain - The chain identifier where the swap will occur
    * @param tokenIn - The address of the input token
    * @param tokenOut - The address of the output token
    * @param amountOut - The desired output amount
-   * @returns Object containing the best protocol, required input amount, and fee tier (for V3)
+   * @returns Object containing the best protocol, required input amount, and fee tier (for V3/V4)
    */
   async findBestProtocolWithAmountOut(chain, tokenIn, tokenOut, amountOut) {
     const destClient = this.dest.client;
@@ -11507,8 +11634,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,
@@ -11516,7 +11643,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,
@@ -11537,7 +11664,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,
@@ -11581,7 +11708,7 @@ var IntentGateway = class {
           currency1,
           fee,
           tickSpacing: this.getTickSpacing(fee),
-          hooks: ADDRESS_ZERO2
+          hooks: ADDRESS_ZERO
           // No hooks
         };
         const quoteResult = (await destClient.simulateContract({
@@ -11648,14 +11775,14 @@ var IntentGateway = class {
     }
   }
   /**
-   * Finds the best Uniswap protocol (V2 or V3) for swapping tokens given an input amount.
+   * Finds the best Uniswap protocol (V2, V3, or V4) for swapping tokens given an input amount.
    * Compares liquidity and pricing across different protocols and fee tiers.
    *
    * @param chain - The chain identifier where the swap will occur
    * @param tokenIn - The address of the input token
    * @param tokenOut - The address of the output token
    * @param amountIn - The input amount to swap
-   * @returns Object containing the best protocol, expected output amount, and fee tier (for V3)
+   * @returns Object containing the best protocol, expected output amount, and fee tier (for V3/V4)
    */
   async findBestProtocolWithAmountIn(chain, tokenIn, tokenOut, amountIn) {
     const destClient = this.dest.client;
@@ -11671,8 +11798,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,
@@ -11680,7 +11807,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,
@@ -11701,7 +11828,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,
@@ -11745,7 +11872,7 @@ var IntentGateway = class {
           currency1,
           fee,
           tickSpacing: this.getTickSpacing(fee),
-          hooks: ADDRESS_ZERO2
+          hooks: ADDRESS_ZERO
           // No hooks
         };
         const quoteResult = (await destClient.simulateContract({
@@ -11811,30 +11938,6 @@ var IntentGateway = class {
       };
     }
   }
-  /**
-   * Converts gas costs to the equivalent amount in the fee token (DAI).
-   * Uses USD pricing to convert between native token gas costs and fee token amounts.
-   *
-   * @param gasEstimate - The estimated gas units
-   * @param publicClient - The client for the chain to get gas prices
-   * @param targetDecimals - The decimal places of the target fee token
-   * @returns The gas cost converted to fee token amount
-   * @private
-   */
-  async convertGasToFeeToken(gasEstimate, publicClient, targetDecimals) {
-    const gasPrice = await publicClient.getGasPrice();
-    const gasCostInWei = gasEstimate * gasPrice;
-    const nativeToken = publicClient.chain?.nativeCurrency;
-    if (!nativeToken?.symbol || !nativeToken?.decimals) {
-      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 gasCostUsd = gasCostInToken * tokenPriceUsd;
-    const feeTokenPriceUsd = await fetchTokenUsdPrice2("DAI");
-    const gasCostInFeeToken = gasCostUsd / feeTokenPriceUsd;
-    return BigInt(Math.floor(gasCostInFeeToken * Math.pow(10, targetDecimals)));
-  }
   /**
    * Checks if an order has been filled by verifying the commitment status on-chain.
    * Reads the storage slot corresponding to the order's commitment hash.
@@ -12199,6 +12302,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