@hyperbridge/sdk 1.8.4 → 1.8.6-rc.1

package/dist/node/index.js

@@ -3,14 +3,14 @@ import { join } from 'path';
 import { TextDecoder as TextDecoder$1, TextEncoder as TextEncoder$1 } from 'util';
 import { createConsola, LogLevels } from 'consola';
 import { flatten, zip, capitalize, maxBy, isNil } from 'lodash-es';
-import { defineChain, keccak256, toHex, createPublicClient, http, hexToBytes, bytesToHex, encodeFunctionData, erc20Abi, bytesToBigInt, pad, toBytes, numberToBytes, encodePacked, encodeAbiParameters, maxUint256, parseAbiParameters, parseAbiItem, isHex, hexToString as hexToString$1, parseEventLogs, parseUnits, concatHex, concat, decodeFunctionData, decodeAbiParameters, formatUnits } from 'viem';
+import { defineChain, keccak256, toHex, createPublicClient, http, hexToBytes, bytesToHex, encodeFunctionData, erc20Abi, bytesToBigInt, pad, toBytes, numberToBytes, getAddress, encodePacked, encodeAbiParameters, maxUint256, parseAbiParameters, parseAbiItem, isHex, hexToString as hexToString$1, parseEventLogs, parseUnits, concatHex, concat, decodeFunctionData, decodeAbiParameters, formatUnits } from 'viem';
 import mergeRace from '@async-generator/merge-race';
 import { baseSepolia, optimismSepolia, arbitrumSepolia, soneium, gnosis, optimism, polygonAmoy, unichain, polygon, base, arbitrum, bsc, mainnet, sepolia, gnosisChiado, bscTestnet, tron } from 'viem/chains';
 import { TronWeb } from 'tronweb';
 import { match } from 'ts-pattern';
 import { WsProvider, ApiPromise, Keyring } from '@polkadot/api';
-import { Struct, Vector, u8, Bytes, Tuple, Enum, _void, u64, u32, Option, bool, u128 } from 'scale-ts';
-import { keccakAsU8a, decodeAddress, keccakAsHex, xxhashAsU8a } from '@polkadot/util-crypto';
+import { Struct, Vector, u8, Bytes, Enum, Tuple, _void, u64, u32, Option, bool, u128 } from 'scale-ts';
+import { keccakAsU8a, decodeAddress, keccakAsHex, xxhashAsU8a, blake2AsU8a } from '@polkadot/util-crypto';
 import { hexToU8a, u8aToHex, u8aConcat } from '@polkadot/util';
 import { hasWindow, isNode, env } from 'std-env';
 import { GraphQLClient } from 'graphql-request';
@@ -4318,6 +4318,8 @@ var getConfigByStateMachineId = (id) => configsByStateMachineId[id];
 var getChainId = (stateMachineId) => configsByStateMachineId[stateMachineId]?.chainId;
 var getViemChain = (chainId) => chainConfigs[chainId]?.viemChain;
 var hyperbridgeAddress = "";
+
+// src/configs/ChainConfigService.ts
 var ChainConfigService = class {
   rpcUrls = {};
   constructor(env2 = process.env) {
@@ -4386,7 +4388,8 @@ var ChainConfigService = class {
   }
   getConsensusStateId(chain) {
     const id = this.getConfig(chain)?.consensusStateId;
-    return id ? toHex(id) : "0x";
+    if (!id) throw new Error(`No consensusStateId configured for chain: ${chain}`);
+    return id;
   }
   getHyperbridgeChainId() {
     return chainConfigs[4009]?.chainId ?? 4009;
@@ -5480,8 +5483,10 @@ var EvmChain = class _EvmChain {
       // Gnosis
       10200: "GNO0",
       // Gnosis Chiado
-      420420417: "PAS0"
+      420420417: "PAS0",
       // Polkadot Asset Hub (Paseo)
+      420420419: "DOT0"
+      // Polkadot Asset Hub (Polkadot)
     };
     if (!params.consensusStateId) {
       params.consensusStateId = defaultConsensusStateIds[params.chainId];
@@ -7060,148 +7065,26 @@ var TronChain = class _TronChain {
     return this.evm.estimateGas(request);
   }
 };
-function getPeakPosByHeight(height) {
-  return (1n << BigInt(height + 1)) - 2n;
-}
-function leftPeakHeightPos(mmrSize) {
-  let height = 1;
-  let prevPos = 0n;
-  let pos = getPeakPosByHeight(height);
-  while (pos < mmrSize) {
-    height += 1;
-    prevPos = pos;
-    pos = getPeakPosByHeight(height);
-  }
-  return [height - 1, prevPos];
-}
-function getRightPeak(initialHeight, initialPos, mmrSize) {
-  let height = initialHeight;
-  let pos = initialPos;
-  pos += siblingOffset(height);
-  while (pos > mmrSize - 1n) {
-    if (height === 0) {
-      return null;
-    }
-    pos -= parentOffset(height - 1);
-    height -= 1;
-  }
-  return [height, pos];
-}
-function getPeaks(mmrSize) {
-  const positions = [];
-  let [height, pos] = leftPeakHeightPos(mmrSize);
-  positions.push(pos);
-  while (height > 0) {
-    const peak = getRightPeak(height, pos, mmrSize);
-    if (!peak) break;
-    [height, pos] = peak;
-    positions.push(pos);
-  }
-  return positions;
-}
-function allOnes(num) {
-  if (num === 0n) return false;
-  return num.toString(2).split("").every((bit) => bit === "1");
-}
-function jumpLeft(pos) {
-  const bitLength = pos.toString(2).length;
-  const mostSignificantBits = 1n << BigInt(bitLength - 1);
-  return pos - (mostSignificantBits - 1n);
-}
-function posHeightInTree(initialPos) {
-  let pos = initialPos + 1n;
-  while (!allOnes(pos)) {
-    pos = jumpLeft(pos);
-  }
-  return pos.toString(2).length - 1;
-}
-function parentOffset(height) {
-  return 2n << BigInt(height);
-}
-function siblingOffset(height) {
-  return (2n << BigInt(height)) - 1n;
-}
-function takeWhileVec(v, p) {
-  const index = v.findIndex((item) => !p(item));
-  if (index === -1) {
-    const result = [...v];
-    v.length = 0;
-    return result;
-  }
-  return v.splice(0, index);
-}
-function mmrPositionToKIndex(initialLeaves, mmrSize) {
-  const leaves = [...initialLeaves];
-  const peaks = getPeaks(mmrSize);
-  const leavesWithKIndices = [];
-  for (const peak of peaks) {
-    const peakLeaves = takeWhileVec(leaves, (pos) => pos <= peak);
-    if (peakLeaves.length > 0) {
-      for (const pos of peakLeaves) {
-        const height = posHeightInTree(peak);
-        let index = 0n;
-        let parentPos = peak;
-        for (let h = height; h >= 1; h--) {
-          const leftChild = parentPos - parentOffset(h - 1);
-          const rightChild = leftChild + siblingOffset(h - 1);
-          index *= 2n;
-          if (leftChild >= pos) {
-            parentPos = leftChild;
-          } else {
-            parentPos = rightChild;
-            index += 1n;
-          }
-        }
-        leavesWithKIndices.push([pos, index]);
-      }
-    }
-  }
-  return leavesWithKIndices;
-}
-function calculateMMRSize(numberOfLeaves) {
-  const numberOfPeaks = numberOfLeaves.toString(2).split("1").length - 1;
-  return 2n * numberOfLeaves - BigInt(numberOfPeaks);
-}
-async function generateRootWithProof(postRequest, treeSize) {
-  const { generate_root_with_proof: generate_root_with_proof2 } = await load_ckb_mmr();
-  const { commitment: hash, encodePacked: encodePacked4 } = postRequestCommitment(postRequest);
-  const result = JSON.parse(generate_root_with_proof2(hexToBytes(encodePacked4), treeSize));
-  const { root, proof, mmr_size, leaf_positions, keccak_hash_calldata } = result;
-  if (keccak_hash_calldata !== hash) {
-    console.log("keccak_hash", keccak_hash_calldata);
-    console.log("hash", hash);
-    throw new Error("Abi keccak hash mismatch");
-  }
-  const [[, kIndex]] = mmrPositionToKIndex(leaf_positions, BigInt(mmr_size));
-  return {
-    root,
-    proof,
-    index: treeSize - 1n,
-    kIndex,
-    treeSize,
-    mmrSize: mmr_size
-  };
-}
-async function load_ckb_mmr() {
-  if (hasWindow) {
-    const wasm2 = await Promise.resolve().then(() => (init_node(), node_exports));
-    await wasm2.default();
-    return wasm2;
-  }
-  if (isNode) {
-    const wasm2 = await Promise.resolve().then(() => (init_node(), node_exports));
-    return wasm2;
-  }
-  throw new Error(`SDK not setup for ${env}`);
-}
-async function __test() {
-  const { generate_root_with_proof: generate_root_with_proof2 } = await load_ckb_mmr();
-  return generate_root_with_proof2(new Uint8Array(), 120n);
+var ReviveContractInfo = Struct({
+  trie_id: Vector(u8)
+});
+var ReviveAccountType = Enum({
+  Contract: ReviveContractInfo
+});
+var ReviveAccountInfo = Struct({
+  account_type: ReviveAccountType
+});
+function decodeReviveContractTrieId(accountData) {
+  const {
+    account_type: { value }
+  } = ReviveAccountInfo.dec(accountData);
+  return value.trie_id;
 }
 var H256 = Vector(u8, 32);
 var EvmStateProof = Struct({
   /**
-   * Proof of the contract state.
+   * Proof of the contract state (EVM account trie) or, for Revive / Substrate EVM, the main state trie proof
+   * (`AccountInfo` + child root) — same SCALE shape as `SubstrateEvmProof::main_proof` on the Rust side.
    */
   contractProof: Vector(Vector(u8)),
   /**
@@ -7580,6 +7463,379 @@ var Message = Enum({
   TimeoutMessage
 });
 
+// src/chains/polkadotHub.ts
+var DEFAULT_CHILD_STORAGE_PREFIX = new TextEncoder().encode(":child_storage:default:");
+var SubstrateHttpRpc = class {
+  constructor(url) {
+    this.url = url;
+  }
+  async call(method, params = []) {
+    const body = JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method,
+      params
+    });
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body
+    });
+    if (!response.ok) {
+      throw new Error(`Substrate RPC HTTP error: ${response.status}`);
+    }
+    const json = await response.json();
+    if (json.error) {
+      throw new Error(`Substrate RPC error: ${json.error.message}`);
+    }
+    return json.result;
+  }
+};
+function contractInfoKey(address20) {
+  const key = new Uint8Array(16 + 16 + 20);
+  key.set(xxhashAsU8a("Revive", 128), 0);
+  key.set(xxhashAsU8a("AccountInfoOf", 128), 16);
+  key.set(address20, 32);
+  return key;
+}
+function childPrefixedStorageKey(trieId) {
+  return u8aConcat(DEFAULT_CHILD_STORAGE_PREFIX, trieId);
+}
+function storageKeyForSlot(slot32) {
+  return blake2AsU8a(slot32, 256);
+}
+function hexKey(k) {
+  return bytesToHex(k);
+}
+var PolkadotHubChain = class _PolkadotHubChain {
+  constructor(params, evm) {
+    this.params = params;
+    this.evm = evm;
+    this.substrateRpc = new SubstrateHttpRpc(replaceWebsocketWithHttp(params.substrateRpcUrl));
+  }
+  evm;
+  substrateRpc;
+  static fromParams(params) {
+    const { substrateRpcUrl, ...evmParams } = params;
+    const evm = EvmChain.fromParams(evmParams);
+    return new _PolkadotHubChain(params, evm);
+  }
+  /**
+   * Creates a `PolkadotHubChain` by auto-detecting the EVM chain ID and `IsmpHost` address via
+   * {@link EvmChain.create}, plus a Substrate RPC URL for Revive child-trie proofs.
+   *
+   * @param evmRpcUrl - HTTP(S) JSON-RPC URL of the EVM (Revive) node
+   * @param substrateRpcUrl - Substrate node RPC (HTTP or WebSocket) for proof queries
+   * @param bundlerUrl - Optional ERC-4337 bundler URL (forwarded to `EvmChain.create`)
+   */
+  static async create(evmRpcUrl, substrateRpcUrl, bundlerUrl) {
+    const evm = await EvmChain.create(evmRpcUrl, bundlerUrl);
+    const chainId = Number.parseInt(evm.config.stateMachineId.replace(/^EVM-/, ""), 10);
+    if (!Number.isFinite(chainId)) {
+      throw new Error(`Unexpected EVM stateMachineId: ${evm.config.stateMachineId}`);
+    }
+    const params = {
+      chainId,
+      rpcUrl: evm.config.rpcUrl,
+      host: evm.config.host,
+      consensusStateId: evm.config.consensusStateId,
+      bundlerUrl: evm.bundlerUrl,
+      substrateRpcUrl
+    };
+    return new _PolkadotHubChain(params, evm);
+  }
+  get client() {
+    return this.evm.client;
+  }
+  get host() {
+    return this.evm.host;
+  }
+  get bundlerUrl() {
+    return this.evm.bundlerUrl;
+  }
+  get configService() {
+    return this.evm.configService;
+  }
+  get config() {
+    return {
+      ...this.evm.config,
+      substrateRpcUrl: this.params.substrateRpcUrl
+    };
+  }
+  hostAddress20() {
+    return hexToBytes(getAddress(this.evm.host));
+  }
+  async fetchCombinedProof(at, queries) {
+    const height = Number(at);
+    if (!Number.isSafeInteger(height) || height < 0) {
+      throw new Error("Block height must be a non-negative safe integer for Substrate RPC");
+    }
+    const blockHash = await this.substrateRpc.call("chain_getBlockHash", [height]);
+    if (!blockHash) {
+      throw new Error(`Block hash not found for height ${height}`);
+    }
+    const mainKeys = [];
+    const childInfoByAddr = /* @__PURE__ */ new Map();
+    const contractEntries = [...queries.entries()];
+    for (const [addr20] of contractEntries) {
+      const infoKey = contractInfoKey(addr20);
+      const storageHex = await this.substrateRpc.call("state_getStorage", [hexKey(infoKey), blockHash]);
+      if (!storageHex) {
+        throw new Error(`Revive AccountInfo not found for contract ${hexKey(addr20)}`);
+      }
+      const trieId = decodeReviveContractTrieId(hexToBytes(storageHex));
+      const prefixed = childPrefixedStorageKey(trieId);
+      mainKeys.push(hexKey(infoKey));
+      mainKeys.push(hexKey(prefixed));
+      childInfoByAddr.set(hexKey(addr20), { trieId, prefixed });
+    }
+    const mainRead = await this.substrateRpc.call("state_getReadProof", [mainKeys, blockHash]);
+    const mainProofBytes = mainRead.proof.map((p) => hexToBytes(p));
+    const storageProofEncoded = /* @__PURE__ */ new Map();
+    for (const [addr20, innerKeys] of contractEntries) {
+      const addrHex = hexKey(addr20);
+      const info = childInfoByAddr.get(addrHex);
+      if (!info) {
+        throw new Error("Internal error: missing child info for contract");
+      }
+      const childKeysHex = innerKeys.map((k) => hexKey(k));
+      const childRead = await this.substrateRpc.call("state_getChildReadProof", [
+        hexKey(info.prefixed),
+        childKeysHex,
+        blockHash
+      ]);
+      storageProofEncoded.set(
+        addr20,
+        childRead.proof.map((p) => hexToBytes(p))
+      );
+    }
+    const encoded = EvmStateProof.enc({
+      contractProof: mainProofBytes,
+      storageProof: Array.from(storageProofEncoded.entries())
+    });
+    return bytesToHex(encoded);
+  }
+  timestamp() {
+    return this.evm.timestamp();
+  }
+  requestReceiptKey(commitment) {
+    return this.evm.requestReceiptKey(commitment);
+  }
+  queryRequestReceipt(commitment) {
+    return this.evm.queryRequestReceipt(commitment);
+  }
+  async queryProof(message, _counterparty, at) {
+    if (at === void 0) {
+      throw new Error("PolkadotHubChain.queryProof requires an explicit block height `at`");
+    }
+    const host = this.hostAddress20();
+    const storageKeys = "Requests" in message ? message.Requests.map((c) => storageKeyForSlot(hexToBytes(requestCommitmentKey(c).slot1))) : message.Responses.map((c) => storageKeyForSlot(hexToBytes(responseCommitmentKey(c))));
+    const q = /* @__PURE__ */ new Map();
+    q.set(host, storageKeys);
+    return this.fetchCombinedProof(at, q);
+  }
+  async queryStateProof(at, keys, _address) {
+    const keyBytes = keys.map((k) => hexToBytes(k));
+    const host = this.hostAddress20();
+    if (keyBytes.every((k) => k.length === 32)) {
+      const storageKeys = keyBytes.map((slot) => storageKeyForSlot(slot));
+      const q = /* @__PURE__ */ new Map();
+      q.set(host, storageKeys);
+      return this.fetchCombinedProof(at, q);
+    }
+    if (keyBytes.every((k) => k.length === 52)) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const full of keyBytes) {
+        const addr = full.subarray(0, 20);
+        const slot = full.subarray(20, 52);
+        const h = hexKey(addr);
+        const arr = groups.get(h) ?? [];
+        arr.push(storageKeyForSlot(slot));
+        groups.set(h, arr);
+      }
+      const q = /* @__PURE__ */ new Map();
+      for (const [addrHex, sks] of groups) {
+        q.set(hexToBytes(addrHex), sks);
+      }
+      return this.fetchCombinedProof(at, q);
+    }
+    throw new Error(
+      "PolkadotHubChain.queryStateProof: keys must be either all 32-byte ISMP slots or all 52-byte (20-byte address + 32-byte slot) entries"
+    );
+  }
+  encode(message) {
+    return this.evm.encode(message);
+  }
+  latestStateMachineHeight(stateMachineId) {
+    return this.evm.latestStateMachineHeight(stateMachineId);
+  }
+  challengePeriod(stateMachineId) {
+    return this.evm.challengePeriod(stateMachineId);
+  }
+  stateMachineUpdateTime(stateMachineHeight) {
+    return this.evm.stateMachineUpdateTime(stateMachineHeight);
+  }
+  getHostNonce() {
+    return this.evm.getHostNonce();
+  }
+  quoteNative(request, fee) {
+    return this.evm.quoteNative(request, fee);
+  }
+  getFeeTokenWithDecimals() {
+    return this.evm.getFeeTokenWithDecimals();
+  }
+  getPlaceOrderCalldata(txHash, intentGatewayAddress) {
+    return this.evm.getPlaceOrderCalldata(txHash, intentGatewayAddress);
+  }
+  estimateGas(request) {
+    return this.evm.estimateGas(request);
+  }
+  broadcastTransaction(signedTransaction) {
+    return this.evm.broadcastTransaction(signedTransaction);
+  }
+  getTransactionReceipt(hash) {
+    return this.evm.getTransactionReceipt(hash);
+  }
+};
+function getPeakPosByHeight(height) {
+  return (1n << BigInt(height + 1)) - 2n;
+}
+function leftPeakHeightPos(mmrSize) {
+  let height = 1;
+  let prevPos = 0n;
+  let pos = getPeakPosByHeight(height);
+  while (pos < mmrSize) {
+    height += 1;
+    prevPos = pos;
+    pos = getPeakPosByHeight(height);
+  }
+  return [height - 1, prevPos];
+}
+function getRightPeak(initialHeight, initialPos, mmrSize) {
+  let height = initialHeight;
+  let pos = initialPos;
+  pos += siblingOffset(height);
+  while (pos > mmrSize - 1n) {
+    if (height === 0) {
+      return null;
+    }
+    pos -= parentOffset(height - 1);
+    height -= 1;
+  }
+  return [height, pos];
+}
+function getPeaks(mmrSize) {
+  const positions = [];
+  let [height, pos] = leftPeakHeightPos(mmrSize);
+  positions.push(pos);
+  while (height > 0) {
+    const peak = getRightPeak(height, pos, mmrSize);
+    if (!peak) break;
+    [height, pos] = peak;
+    positions.push(pos);
+  }
+  return positions;
+}
+function allOnes(num) {
+  if (num === 0n) return false;
+  return num.toString(2).split("").every((bit) => bit === "1");
+}
+function jumpLeft(pos) {
+  const bitLength = pos.toString(2).length;
+  const mostSignificantBits = 1n << BigInt(bitLength - 1);
+  return pos - (mostSignificantBits - 1n);
+}
+function posHeightInTree(initialPos) {
+  let pos = initialPos + 1n;
+  while (!allOnes(pos)) {
+    pos = jumpLeft(pos);
+  }
+  return pos.toString(2).length - 1;
+}
+function parentOffset(height) {
+  return 2n << BigInt(height);
+}
+function siblingOffset(height) {
+  return (2n << BigInt(height)) - 1n;
+}
+function takeWhileVec(v, p) {
+  const index = v.findIndex((item) => !p(item));
+  if (index === -1) {
+    const result = [...v];
+    v.length = 0;
+    return result;
+  }
+  return v.splice(0, index);
+}
+function mmrPositionToKIndex(initialLeaves, mmrSize) {
+  const leaves = [...initialLeaves];
+  const peaks = getPeaks(mmrSize);
+  const leavesWithKIndices = [];
+  for (const peak of peaks) {
+    const peakLeaves = takeWhileVec(leaves, (pos) => pos <= peak);
+    if (peakLeaves.length > 0) {
+      for (const pos of peakLeaves) {
+        const height = posHeightInTree(peak);
+        let index = 0n;
+        let parentPos = peak;
+        for (let h = height; h >= 1; h--) {
+          const leftChild = parentPos - parentOffset(h - 1);
+          const rightChild = leftChild + siblingOffset(h - 1);
+          index *= 2n;
+          if (leftChild >= pos) {
+            parentPos = leftChild;
+          } else {
+            parentPos = rightChild;
+            index += 1n;
+          }
+        }
+        leavesWithKIndices.push([pos, index]);
+      }
+    }
+  }
+  return leavesWithKIndices;
+}
+function calculateMMRSize(numberOfLeaves) {
+  const numberOfPeaks = numberOfLeaves.toString(2).split("1").length - 1;
+  return 2n * numberOfLeaves - BigInt(numberOfPeaks);
+}
+async function generateRootWithProof(postRequest, treeSize) {
+  const { generate_root_with_proof: generate_root_with_proof2 } = await load_ckb_mmr();
+  const { commitment: hash, encodePacked: encodePacked4 } = postRequestCommitment(postRequest);
+  const result = JSON.parse(generate_root_with_proof2(hexToBytes(encodePacked4), treeSize));
+  const { root, proof, mmr_size, leaf_positions, keccak_hash_calldata } = result;
+  if (keccak_hash_calldata !== hash) {
+    console.log("keccak_hash", keccak_hash_calldata);
+    console.log("hash", hash);
+    throw new Error("Abi keccak hash mismatch");
+  }
+  const [[, kIndex]] = mmrPositionToKIndex(leaf_positions, BigInt(mmr_size));
+  return {
+    root,
+    proof,
+    index: treeSize - 1n,
+    kIndex,
+    treeSize,
+    mmrSize: mmr_size
+  };
+}
+async function load_ckb_mmr() {
+  if (hasWindow) {
+    const wasm2 = await Promise.resolve().then(() => (init_node(), node_exports));
+    await wasm2.default();
+    return wasm2;
+  }
+  if (isNode) {
+    const wasm2 = await Promise.resolve().then(() => (init_node(), node_exports));
+    return wasm2;
+  }
+  throw new Error(`SDK not setup for ${env}`);
+}
+async function __test() {
+  const { generate_root_with_proof: generate_root_with_proof2 } = await load_ckb_mmr();
+  return generate_root_with_proof2(new Uint8Array(), 120n);
+}
+
 // src/utils.ts
 var DEFAULT_POLL_INTERVAL = 5e3;
 var ADDRESS_ZERO2 = "0x0000000000000000000000000000000000000000";
@@ -15670,7 +15926,7 @@ var BidManager = class {
     const {
       order,
       solverAccount,
-      solverPrivateKey,
+      solverSigner,
       nonce,
       entryPointAddress,
       callGasLimit,
@@ -15699,8 +15955,7 @@ var BidManager = class {
     const userOpHash = this.crypto.computeUserOpHash(userOp, entryPointAddress, chainId);
     const sessionKey = order.session;
     const messageHash = keccak256(concat([userOpHash, order.id, sessionKey]));
-    const solverAccount_ = privateKeyToAccount(solverPrivateKey);
-    const solverSignature = await solverAccount_.signMessage({ message: { raw: messageHash } });
+    const solverSignature = await solverSigner.signMessage(messageHash, Number(chainId));
     const signature = concat([order.id, solverSignature]);
     return { ...userOp, signature };
   }
@@ -18662,9 +18917,9 @@ async function fetchLocalAssetId(params) {
   const palletPrefix = xxhashAsU8a("TokenGateway", 128);
   const storagePrefix = xxhashAsU8a("LocalAssets", 128);
   const full_key = new Uint8Array([...palletPrefix, ...storagePrefix, ...assetId]);
-  const hexKey = bytesToHex(full_key);
+  const hexKey2 = bytesToHex(full_key);
   const storage_value = await api.rpc.state.getStorage(
-    hexKey
+    hexKey2
   );
   if (storage_value.isSome) {
     const assetId2 = storage_value.value.toU8a();
@@ -18937,6 +19192,6 @@ async function teleportDot(param_) {
   return stream;
 }
 
-export { ADDRESS_ZERO2 as ADDRESS_ZERO, BundlerMethod, ChainConfigService, Chains, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, ERC20Method, ERC7821_BATCH_MODE, EvmChain, ABI as EvmHostABI, EvmLanguage, HyperClientStatus, IndexerClient, IntentGateway, ABI7 as IntentGatewayV2ABI, IntentOrderStatus, IntentsCoprocessor, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, OrderStatus, OrderStatusChecker, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, SubstrateChain, Swap, TESTNET_CHAINS, TeleportStatus, TimeoutStatus, TokenGateway, TronChain, USE_ETHERSCAN_CHAINS, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, orderCommitment, parseStateMachineId, polkadotAssetHubPaseo, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };
+export { ADDRESS_ZERO2 as ADDRESS_ZERO, BundlerMethod, ChainConfigService, Chains, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, ERC20Method, ERC7821_BATCH_MODE, EvmChain, ABI as EvmHostABI, EvmLanguage, HyperClientStatus, IndexerClient, IntentGateway, ABI7 as IntentGatewayV2ABI, IntentOrderStatus, IntentsCoprocessor, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, OrderStatus, OrderStatusChecker, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, PolkadotHubChain, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, SubstrateChain, Swap, TESTNET_CHAINS, TeleportStatus, TimeoutStatus, TokenGateway, TronChain, USE_ETHERSCAN_CHAINS, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, orderCommitment, parseStateMachineId, polkadotAssetHubPaseo, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map