@hyperbridge/sdk 1.3.4 → 1.3.6

package/dist/node/index.js

@@ -3,7 +3,7 @@ import { join } from 'path';
 import { TextDecoder as TextDecoder$1, TextEncoder as TextEncoder$1 } from 'util';
 import { createConsola, LogLevels } from 'consola';
 import { flatten, zip, capitalize, maxBy, isNil } from 'lodash-es';
-import { toHex, hexToBytes, encodePacked, keccak256, encodeAbiParameters, bytesToHex, concatHex, createPublicClient, http, encodeFunctionData, erc20Abi, bytesToBigInt, pad, toBytes, maxUint256, parseUnits } from 'viem';
+import { toHex, hexToBytes, encodePacked, keccak256, encodeAbiParameters, bytesToHex, concatHex, createPublicClient, http, encodeFunctionData, erc20Abi, bytesToBigInt, pad, toBytes, maxUint256, formatUnits, parseUnits } from 'viem';
 import mergeRace from '@async-generator/merge-race';
 import { gnosisChiado, gnosis, bscTestnet, bsc, soneium, baseSepolia, base, optimismSepolia, optimism, arbitrumSepolia, arbitrum, mainnet, sepolia } from 'viem/chains';
 import { hasWindow, isNode, env } from 'std-env';
@@ -13,6 +13,7 @@ import { WsProvider, ApiPromise } from '@polkadot/api';
 import { RpcWebSocketClient } from 'rpc-websocket-client';
 import { keccakAsU8a, decodeAddress, xxhashAsU8a } from '@polkadot/util-crypto';
 import { GraphQLClient } from 'graphql-request';
+import { Decimal } from 'decimal.js';
 import { u8aToHex } from '@polkadot/util';
 
 var __defProp = Object.defineProperty;
@@ -3410,18 +3411,18 @@ var addresses = {
     ["EVM-10200" /* GNOSIS_CHIADO */]: "0x0000000000000000000000000000000000000000",
     ["EVM-11155111" /* SEPOLIA */]: "0x0000000000000000000000000000000000000000",
     ["EVM-1" /* MAINNET */]: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
-    ["EVM-56" /* BSC_MAINNET */]: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
-    ["EVM-42161" /* ARBITRUM_MAINNET */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-8453" /* BASE_MAINNET */]: "0x0000000000000000000000000000000000000000"
+    ["EVM-56" /* BSC_MAINNET */]: "0x10ED43C718714eb63d5aA57B78B54704E256024E",
+    ["EVM-42161" /* ARBITRUM_MAINNET */]: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
+    ["EVM-8453" /* BASE_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",
-    ["EVM-42161" /* ARBITRUM_MAINNET */]: "0x0000000000000000000000000000000000000000",
-    ["EVM-8453" /* BASE_MAINNET */]: "0x0000000000000000000000000000000000000000"
+    ["EVM-56" /* BSC_MAINNET */]: "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73",
+    ["EVM-42161" /* ARBITRUM_MAINNET */]: "0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9",
+    ["EVM-8453" /* BASE_MAINNET */]: "0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6"
   },
   BatchExecutor: {
     ["EVM-97" /* BSC_CHAPEL */]: "0x4CC58B5D8FBf838d062E4b21F75C327835B5F0ef",
@@ -3933,6 +3934,10 @@ var GetRequest = Struct({
    * Substrate Keys
    */
   keys: Vector(Vector(u8)),
+  /*
+   * The height of the state machine
+   */
+  height: u64,
   /*
    * Some application-specific metadata relating to this request
    */
@@ -4059,6 +4064,24 @@ var TimeoutMessage = Enum({
     requests: Vector(Request)
   })
 });
+var GetRequestsWithProof = Struct({
+  /*
+   * Requests to be fetched
+   */
+  requests: Vector(GetRequest),
+  /*
+   * Membership batch proof for these requests
+   */
+  source: Proof,
+  /*
+   * Storage proof for these responses
+   */
+  response: Proof,
+  /*
+   * Signer information. Ideally should be their account identifier
+   */
+  signer: Vector(u8)
+});
 var Message = Enum({
   /*
    * A consensus update message
@@ -4807,6 +4830,8 @@ var EvmChain = class {
         ]
       });
       return encoded2;
+    }).with({ kind: "GetRequest" }, (message2) => {
+      throw new Error("GetResponse is not yet supported on Substrate chains");
     }).exhaustive();
     return encoded;
   }
@@ -5122,8 +5147,13 @@ var SubstrateChain = class {
   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);
+    const args = encodeISMPMessage(message);
+    let tx;
+    if (message.kind === "GetRequest") {
+      tx = api.tx.stateCoprocessor.handleUnsigned(args);
+    } else {
+      tx = api.tx.ismp.handleUnsigned(args);
+    }
     return new Promise((resolve, reject) => {
       let unsub = () => {
       };
@@ -5266,6 +5296,18 @@ function convertIPostRequestToCodec(request) {
     }
   };
 }
+function convertIGetRequestToCodec(request) {
+  return {
+    source: convertStateMachineIdToEnum(request.source),
+    dest: convertStateMachineIdToEnum(request.dest),
+    from: Array.from(hexToBytes(request.from)),
+    nonce: request.nonce,
+    keys: request.keys.map((key) => Array.from(hexToBytes(key))),
+    context: Array.from(hexToBytes(request.context)),
+    timeoutTimestamp: request.timeoutTimestamp,
+    height: request.height
+  };
+}
 function encodeISMPMessage(message) {
   try {
     return match(message).with({ kind: "PostRequest" }, (message2) => {
@@ -5292,6 +5334,31 @@ function encodeISMPMessage(message) {
       ]);
     }).with({ kind: "GetResponse" }, (message2) => {
       throw new Error("GetResponse is not yet supported on Substrate chains");
+    }).with({ kind: "GetRequest" }, (message2) => {
+      return GetRequestsWithProof.enc({
+        requests: message2.requests.map((request) => convertIGetRequestToCodec(request)),
+        source: {
+          height: {
+            height: message2.source.height,
+            id: {
+              consensusStateId: Array.from(toBytes(message2.source.consensusStateId)),
+              id: convertStateMachineIdToEnum(message2.source.stateMachine)
+            }
+          },
+          proof: Array.from(hexToBytes(message2.source.proof))
+        },
+        response: {
+          height: {
+            height: message2.response.height,
+            id: {
+              consensusStateId: Array.from(toBytes(message2.response.consensusStateId)),
+              id: convertStateMachineIdToEnum(message2.response.stateMachine)
+            }
+          },
+          proof: Array.from(hexToBytes(message2.response.proof))
+        },
+        signer: Array.from(hexToBytes(message2.signer))
+      });
     }).with({ kind: "TimeoutPostRequest" }, (message2) => {
       return Vector(Message).enc([
         {
@@ -5692,6 +5759,7 @@ async function _queryGetRequestInternal(params) {
   const { statusMetadata, ...rest } = response.getRequests.nodes[0];
   return {
     ...rest,
+    commitment: commitmentHash,
     timeoutTimestamp: BigInt(rest.timeoutTimestamp),
     nonce: BigInt(rest.nonce),
     height: BigInt(rest.height),
@@ -6109,6 +6177,120 @@ var IndexerClient = class {
     );
     return request;
   }
+  /**
+   * Queries a GET request and returns it alongside its statuses,
+   * including any finalization events.
+   * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
+   * @returns Full GET request data with all inferred status events, including SOURCE_FINALIZED and HYPERBRIDGE_FINALIZED
+   * @remarks Unlike queryGetRequest(), this method adds derived finalization status events by querying state machine updates
+   */
+  async queryGetRequestWithStatus(hash) {
+    let request = await this.queryGetRequest(hash);
+    if (!request) return;
+    request = await this.addGetRequestFinalityEvents(request);
+    request.statuses = request.statuses.sort(
+      (a, b) => COMBINED_STATUS_WEIGHTS[a.status] - COMBINED_STATUS_WEIGHTS[b.status]
+    );
+    return request;
+  }
+  /**
+   * Enhances a GET request with finality events by querying state machine updates.
+   *
+   * This method augments a GET request object with additional inferred status events
+   * that represent chain finality confirmations. It adds:
+   * - SOURCE_FINALIZED: When the source chain has finalized the request
+   * - HYPERBRIDGE_FINALIZED: When Hyperbridge has finalized the delivery confirmation and response is ready
+   *
+   * The method also generates appropriate calldata for submitting cross-chain proofs
+   * when applicable.
+   *
+   * @param request - The GET request to enhance with finality events
+   * @returns The request with finality events added
+   * @private
+   */
+  async addGetRequestFinalityEvents(request) {
+    const events = [];
+    const addFinalityEvents = (request2) => {
+      this.logger.trace(`Added ${events.length} \`GetRequest\` finality events`, events);
+      request2.statuses = [...request2.statuses, ...events];
+      return request2;
+    };
+    let hyperbridgeDelivered;
+    if (request.source === this.config.hyperbridge.stateMachineId) {
+      hyperbridgeDelivered = request.statuses[0];
+      return addFinalityEvents(request);
+    } else {
+      const sourceFinality = await this.queryStateMachineUpdateByHeight({
+        statemachineId: request.source,
+        height: request.statuses[0].metadata.blockNumber,
+        chain: this.config.hyperbridge.stateMachineId
+      });
+      if (!sourceFinality) return addFinalityEvents(request);
+      events.push({
+        status: RequestStatus.SOURCE_FINALIZED,
+        metadata: {
+          blockHash: sourceFinality.blockHash,
+          blockNumber: sourceFinality.height,
+          transactionHash: sourceFinality.transactionHash,
+          timestamp: sourceFinality.timestamp
+        }
+      });
+      hyperbridgeDelivered = request.statuses.find((item) => item.status === RequestStatus.HYPERBRIDGE_DELIVERED);
+      if (!hyperbridgeDelivered) return addFinalityEvents(request);
+    }
+    const hyperbridgeFinality = await this.queryStateMachineUpdateByHeight({
+      statemachineId: this.config.hyperbridge.stateMachineId,
+      height: hyperbridgeDelivered.metadata.blockNumber,
+      chain: request.source
+    });
+    if (!hyperbridgeFinality) return addFinalityEvents(request);
+    const sourceChain = await getChain(this.config.source);
+    const hyperbridge = await getChain({
+      ...this.config.hyperbridge,
+      hasher: "Keccak"
+    });
+    try {
+      const response = await this.queryResponseByRequestId(request.commitment);
+      if (!response) return addFinalityEvents(request);
+      const proof = await hyperbridge.queryProof(
+        { Responses: [response.commitment] },
+        request.source,
+        BigInt(hyperbridgeFinality.height)
+      );
+      const calldata = sourceChain.encode({
+        kind: "GetResponse",
+        proof: {
+          stateMachine: this.config.hyperbridge.stateMachineId,
+          consensusStateId: this.config.hyperbridge.consensusStateId,
+          proof,
+          height: BigInt(hyperbridgeFinality.height)
+        },
+        responses: [
+          {
+            get: request,
+            values: request.keys.map((key, index) => ({
+              key,
+              value: response.values[index] || "0x"
+            }))
+          }
+        ],
+        signer: pad("0x")
+      });
+      events.push({
+        status: RequestStatus.HYPERBRIDGE_FINALIZED,
+        metadata: {
+          blockHash: hyperbridgeFinality.blockHash,
+          blockNumber: hyperbridgeFinality.height,
+          transactionHash: hyperbridgeFinality.transactionHash,
+          timestamp: hyperbridgeFinality.timestamp,
+          calldata
+        }
+      });
+    } catch (error) {
+      this.logger.trace("Could not generate HYPERBRIDGE_FINALIZED event for GET request:", error);
+    }
+    return addFinalityEvents(request);
+  }
   /**
    * Create a Stream of status updates for a post request.
    * Stream ends when either the request reaches the destination or times out.
@@ -11373,8 +11555,6 @@ var UNISWAP_V4_QUOTER_ABI = [
     inputs: [{ name: "revertData", type: "bytes", internalType: "bytes" }]
   }
 ];
-
-// src/protocols/intents.ts
 var IntentGateway = class {
   /**
    * Creates a new IntentGateway instance for cross-chain operations.
@@ -11402,14 +11582,10 @@ var IntentGateway = class {
       from: this.source.config.getIntentGatewayAddress(order.destChain),
       to: this.source.config.getIntentGatewayAddress(order.sourceChain)
     };
-    const { decimals: sourceChainFeeTokenDecimals, address: sourceChainFeeTokenAddress } = await this.source.getFeeTokenWithDecimals();
+    const { decimals: sourceChainFeeTokenDecimals } = await this.source.getFeeTokenWithDecimals();
     const { address: destChainFeeTokenAddress, decimals: destChainFeeTokenDecimals } = await this.dest.getFeeTokenWithDecimals();
     const { gas: postGasEstimate, postRequestCalldata } = await this.source.estimateGas(postRequest);
-    const postGasEstimateInSourceFeeToken = await this.convertGasToFeeToken(
-      postGasEstimate,
-      this.source.client,
-      sourceChainFeeTokenDecimals
-    );
+    const postGasEstimateInSourceFeeToken = await this.convertGasToFeeToken(postGasEstimate, "source");
     const relayerFeeInSourceFeeToken = postGasEstimateInSourceFeeToken + 25n * 10n ** BigInt(sourceChainFeeTokenDecimals - 2);
     const relayerFeeInDestFeeToken = adjustFeeDecimals(
       relayerFeeInSourceFeeToken,
@@ -11464,6 +11640,7 @@ var IntentGateway = class {
       }))
     ];
     let destChainFillGas = 0n;
+    let filledWithNativeToken = false;
     try {
       let protocolFeeInNativeToken = await this.quoteNative(postRequest, relayerFeeInDestFeeToken);
       protocolFeeInNativeToken = protocolFeeInNativeToken + protocolFeeInNativeToken * 50n / 10000n;
@@ -11476,6 +11653,7 @@ var IntentGateway = class {
         value: totalEthValue + protocolFeeInNativeToken,
         stateOverride: stateOverrides
       });
+      filledWithNativeToken = true;
     } 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`
@@ -11510,28 +11688,25 @@ var IntentGateway = class {
         stateOverride: stateOverrides
       });
     }
-    const fillGasInSourceFeeToken = await this.convertGasToFeeToken(
-      destChainFillGas,
-      this.dest.client,
+    const fillGasInDestFeeToken = await this.convertGasToFeeToken(destChainFillGas, "dest");
+    const fillGasInSourceFeeToken = adjustFeeDecimals(
+      fillGasInDestFeeToken,
+      destChainFeeTokenDecimals,
       sourceChainFeeTokenDecimals
     );
     const protocolFeeInSourceFeeToken = adjustFeeDecimals(
-      // Following baseIsmpModule.sol, the protocol fee is added to the relayer fee
-      await this.dest.quote(postRequest) + relayerFeeInDestFeeToken,
+      await this.dest.quote(postRequest),
       destChainFeeTokenDecimals,
       sourceChainFeeTokenDecimals
     );
-    const totalEstimate = fillGasInSourceFeeToken + protocolFeeInSourceFeeToken + relayerFeeInSourceFeeToken;
-    const SWAP_OPERATIONS_BPS = 3500n;
-    const swapOperationsInFeeToken = totalEstimate * SWAP_OPERATIONS_BPS / 10000n;
-    const totalFeeTokenAmount = totalEstimate + swapOperationsInFeeToken;
-    const totalNativeTokenAmount = await this.convertFeeTokenToNative(
-      totalFeeTokenAmount,
-      this.source.client,
-      sourceChainFeeTokenDecimals
-    );
+    let totalEstimateInSourceFeeToken = fillGasInSourceFeeToken + protocolFeeInSourceFeeToken + relayerFeeInSourceFeeToken;
+    if (!filledWithNativeToken) {
+      totalEstimateInSourceFeeToken = totalEstimateInSourceFeeToken + totalEstimateInSourceFeeToken * 200n / 10000n;
+    }
+    let totalNativeTokenAmount = await this.convertFeeTokenToNative(totalEstimateInSourceFeeToken, "source");
+    totalNativeTokenAmount = totalNativeTokenAmount + totalNativeTokenAmount * 200n / 10000n;
     return {
-      feeTokenAmount: totalFeeTokenAmount,
+      feeTokenAmount: totalEstimateInSourceFeeToken,
       nativeTokenAmount: totalNativeTokenAmount,
       postRequestCalldata
     };
@@ -11541,47 +11716,82 @@ var IntentGateway = class {
    * 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
+   * @param getQuoteIn - Whether to use "source" or "dest" chain for the conversion
    * @returns The fee token amount converted to native token amount
    * @private
    */
-  async convertFeeTokenToNative(feeTokenAmount, publicClient, feeTokenDecimals) {
-    const nativeToken = publicClient.chain?.nativeCurrency;
-    const chainId = publicClient.chain?.id;
-    if (!nativeToken?.symbol || !nativeToken?.decimals) {
-      throw new Error("Chain native currency information not available");
+  async convertFeeTokenToNative(feeTokenAmount, getQuoteIn) {
+    const client = this[getQuoteIn].client;
+    const evmChainID = `EVM-${client.chain?.id}`;
+    const wethAsset = this[getQuoteIn].config.getWrappedNativeAssetWithDecimals(evmChainID).asset;
+    const feeToken = await this[getQuoteIn].getFeeTokenWithDecimals();
+    try {
+      const { amountOut } = await this.findBestProtocolWithAmountIn(
+        getQuoteIn,
+        feeToken.address,
+        wethAsset,
+        feeTokenAmount,
+        "v2"
+      );
+      if (amountOut === 0n) {
+        throw new Error();
+      }
+      return amountOut;
+    } catch {
+      const nativeCurrency = client.chain?.nativeCurrency;
+      const chainId = client.chain?.id;
+      const feeTokenAmountDecimal = new Decimal(formatUnits(feeTokenAmount, feeToken.decimals));
+      const nativeTokenPriceUsd = new Decimal(await fetchPrice(nativeCurrency?.symbol, chainId));
+      const totalCostInNativeToken = feeTokenAmountDecimal.dividedBy(nativeTokenPriceUsd);
+      return parseUnits(totalCostInNativeToken.toFixed(nativeCurrency?.decimals), nativeCurrency?.decimals);
     }
-    const feeTokenAmountNumber = Number(feeTokenAmount) / Math.pow(10, feeTokenDecimals);
-    const nativeTokenPriceUsd = await fetchPrice(nativeToken.symbol, chainId);
-    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
+   * @param gasEstimateIn - Whether to use "source" or "dest" chain for the conversion
    * @returns The gas cost converted to fee token amount
    * @private
    */
-  async convertGasToFeeToken(gasEstimate, publicClient, targetDecimals) {
-    const gasPrice = await publicClient.getGasPrice();
+  async convertGasToFeeToken(gasEstimate, gasEstimateIn) {
+    const client = this[gasEstimateIn].client;
+    const gasPrice = await client.getGasPrice();
     const gasCostInWei = gasEstimate * gasPrice;
-    const nativeToken = publicClient.chain?.nativeCurrency;
-    const chainId = publicClient.chain?.id;
-    if (!nativeToken?.symbol || !nativeToken?.decimals) {
-      throw new Error("Chain native currency information not available");
+    const evmChainID = `EVM-${client.chain?.id}`;
+    const wethAddr = this[gasEstimateIn].config.getWrappedNativeAssetWithDecimals(evmChainID).asset;
+    const feeToken = await this[gasEstimateIn].getFeeTokenWithDecimals();
+    try {
+      const { amountOut } = await this.findBestProtocolWithAmountIn(
+        gasEstimateIn,
+        wethAddr,
+        feeToken.address,
+        gasCostInWei,
+        "v2"
+      );
+      if (amountOut === 0n) {
+        throw new Error();
+      }
+      return amountOut;
+    } catch {
+      const nativeCurrency = client.chain?.nativeCurrency;
+      const chainId = client.chain?.id;
+      const gasCostInToken = new Decimal(formatUnits(gasCostInWei, nativeCurrency?.decimals));
+      const tokenPriceUsd = await fetchPrice(nativeCurrency?.symbol, chainId);
+      const gasCostUsd = gasCostInToken.times(tokenPriceUsd);
+      const feeTokenPriceUsd = new Decimal(1);
+      const gasCostInFeeToken = gasCostUsd.dividedBy(feeTokenPriceUsd);
+      return parseUnits(gasCostInFeeToken.toFixed(feeToken.decimals), feeToken.decimals);
     }
-    const gasCostInToken = Number(gasCostInWei) / Math.pow(10, nativeToken.decimals);
-    const tokenPriceUsd = await fetchPrice(nativeToken.symbol, chainId);
-    const gasCostUsd = gasCostInToken * tokenPriceUsd;
-    const feeTokenPriceUsd = await fetchPrice("DAI");
-    const gasCostInFeeToken = gasCostUsd / feeTokenPriceUsd;
-    return BigInt(Math.floor(gasCostInFeeToken * Math.pow(10, targetDecimals)));
   }
+  /**
+   * Gets a quote for the native token cost of dispatching a post request.
+   *
+   * @param postRequest - The post request to quote
+   * @param fee - The fee amount in fee token
+   * @returns The native token amount required
+   */
   async quoteNative(postRequest, fee) {
     const dispatchPost = {
       dest: toHex(postRequest.dest),
@@ -11603,37 +11813,38 @@ var IntentGateway = class {
    * 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 getQuoteIn - Whether to use "source" or "dest" chain for the swap
    * @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/V4)
    */
-  async findBestProtocolWithAmountOut(chain, tokenIn, tokenOut, amountOut) {
-    const destClient = this.dest.client;
+  async findBestProtocolWithAmountOut(getQuoteIn, tokenIn, tokenOut, amountOut) {
+    const client = this[getQuoteIn].client;
+    const evmChainID = `EVM-${client.chain?.id}`;
     let amountInV2 = maxUint256;
     let amountInV3 = maxUint256;
     let amountInV4 = maxUint256;
     let bestV3Fee = 0;
     let bestV4Fee = 0;
     const commonFees = [100, 500, 3e3, 1e4];
-    const v2Router = this.source.config.getUniswapRouterV2Address(chain);
-    const v2Factory = this.source.config.getUniswapV2FactoryAddress(chain);
-    const v3Factory = this.source.config.getUniswapV3FactoryAddress(chain);
-    const v3Quoter = this.source.config.getUniswapV3QuoterAddress(chain);
-    const v4Quoter = this.source.config.getUniswapV4QuoterAddress(chain);
-    const wethAsset = this.source.config.getWrappedNativeAssetWithDecimals(chain).asset;
+    const v2Router = this.source.config.getUniswapRouterV2Address(evmChainID);
+    const v2Factory = this.source.config.getUniswapV2FactoryAddress(evmChainID);
+    const v3Factory = this.source.config.getUniswapV3FactoryAddress(evmChainID);
+    const v3Quoter = this.source.config.getUniswapV3QuoterAddress(evmChainID);
+    const v4Quoter = this.source.config.getUniswapV4QuoterAddress(evmChainID);
+    const wethAsset = this.source.config.getWrappedNativeAssetWithDecimals(evmChainID).asset;
     const tokenInForQuote = tokenIn === ADDRESS_ZERO ? wethAsset : tokenIn;
     const tokenOutForQuote = tokenOut === ADDRESS_ZERO ? wethAsset : tokenOut;
     try {
-      const v2PairExists = await destClient.readContract({
+      const v2PairExists = await client.readContract({
         address: v2Factory,
         abi: uniswapV2Factory_default.ABI,
         functionName: "getPair",
         args: [tokenInForQuote, tokenOutForQuote]
       });
       if (v2PairExists !== ADDRESS_ZERO) {
-        const v2AmountIn = await destClient.readContract({
+        const v2AmountIn = await client.readContract({
           address: v2Router,
           abi: uniswapRouterV2_default.ABI,
           functionName: "getAmountsIn",
@@ -11647,20 +11858,20 @@ var IntentGateway = class {
     let bestV3AmountIn = maxUint256;
     for (const fee of commonFees) {
       try {
-        const pool = await destClient.readContract({
+        const pool = await client.readContract({
           address: v3Factory,
           abi: uniswapV3Factory_default.ABI,
           functionName: "getPool",
           args: [tokenInForQuote, tokenOutForQuote, fee]
         });
         if (pool !== ADDRESS_ZERO) {
-          const liquidity = await destClient.readContract({
+          const liquidity = await client.readContract({
             address: pool,
             abi: uniswapV3Pool_default.ABI,
             functionName: "liquidity"
           });
           if (liquidity > BigInt(0)) {
-            const quoteResult = (await destClient.simulateContract({
+            const quoteResult = (await client.simulateContract({
               address: v3Quoter,
               abi: uniswapV3Quoter_default.ABI,
               functionName: "quoteExactOutputSingle",
@@ -11700,7 +11911,7 @@ var IntentGateway = class {
           hooks: ADDRESS_ZERO
           // No hooks
         };
-        const quoteResult = (await destClient.simulateContract({
+        const quoteResult = (await client.simulateContract({
           address: v4Quoter,
           abi: UNISWAP_V4_QUOTER_ABI,
           functionName: "quoteExactOutputSingle",
@@ -11767,43 +11978,48 @@ var IntentGateway = class {
    * 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 getQuoteIn - Whether to use "source" or "dest" chain for the swap
    * @param tokenIn - The address of the input token
    * @param tokenOut - The address of the output token
    * @param amountIn - The input amount to swap
+   * @param selectedProtocol - Optional specific protocol to use ("v2", "v3", or "v4")
    * @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;
+  async findBestProtocolWithAmountIn(getQuoteIn, tokenIn, tokenOut, amountIn, selectedProtocol) {
+    const client = this[getQuoteIn].client;
+    const evmChainID = `EVM-${client.chain?.id}`;
     let amountOutV2 = BigInt(0);
     let amountOutV3 = BigInt(0);
     let amountOutV4 = BigInt(0);
     let bestV3Fee = 0;
     let bestV4Fee = 0;
     const commonFees = [100, 500, 3e3, 1e4];
-    const v2Router = this.source.config.getUniswapRouterV2Address(chain);
-    const v2Factory = this.source.config.getUniswapV2FactoryAddress(chain);
-    const v3Factory = this.source.config.getUniswapV3FactoryAddress(chain);
-    const v3Quoter = this.source.config.getUniswapV3QuoterAddress(chain);
-    const v4Quoter = this.source.config.getUniswapV4QuoterAddress(chain);
-    const wethAsset = this.source.config.getWrappedNativeAssetWithDecimals(chain).asset;
+    const v2Router = this.source.config.getUniswapRouterV2Address(evmChainID);
+    const v2Factory = this.source.config.getUniswapV2FactoryAddress(evmChainID);
+    const v3Factory = this.source.config.getUniswapV3FactoryAddress(evmChainID);
+    const v3Quoter = this.source.config.getUniswapV3QuoterAddress(evmChainID);
+    const v4Quoter = this.source.config.getUniswapV4QuoterAddress(evmChainID);
+    const wethAsset = this.source.config.getWrappedNativeAssetWithDecimals(evmChainID).asset;
     const tokenInForQuote = tokenIn === ADDRESS_ZERO ? wethAsset : tokenIn;
     const tokenOutForQuote = tokenOut === ADDRESS_ZERO ? wethAsset : tokenOut;
     try {
-      const v2PairExists = await destClient.readContract({
+      const v2PairExists = await client.readContract({
         address: v2Factory,
         abi: uniswapV2Factory_default.ABI,
         functionName: "getPair",
         args: [tokenInForQuote, tokenOutForQuote]
       });
       if (v2PairExists !== ADDRESS_ZERO) {
-        const v2AmountOut = await destClient.readContract({
+        const v2AmountOut = await client.readContract({
           address: v2Router,
           abi: uniswapRouterV2_default.ABI,
           functionName: "getAmountsOut",
           args: [amountIn, [tokenInForQuote, tokenOutForQuote]]
         });
         amountOutV2 = v2AmountOut[1];
+        if (selectedProtocol === "v2") {
+          return { protocol: "v2", amountOut: amountOutV2 };
+        }
       }
     } catch (error) {
       console.warn("V2 quote failed:", error);
@@ -11811,20 +12027,20 @@ var IntentGateway = class {
     let bestV3AmountOut = BigInt(0);
     for (const fee of commonFees) {
       try {
-        const pool = await destClient.readContract({
+        const pool = await client.readContract({
           address: v3Factory,
           abi: uniswapV3Factory_default.ABI,
           functionName: "getPool",
           args: [tokenInForQuote, tokenOutForQuote, fee]
         });
         if (pool !== ADDRESS_ZERO) {
-          const liquidity = await destClient.readContract({
+          const liquidity = await client.readContract({
             address: pool,
             abi: uniswapV3Pool_default.ABI,
             functionName: "liquidity"
           });
           if (liquidity > BigInt(0)) {
-            const quoteResult = (await destClient.simulateContract({
+            const quoteResult = (await client.simulateContract({
               address: v3Quoter,
               abi: uniswapV3Quoter_default.ABI,
               functionName: "quoteExactInputSingle",
@@ -11850,6 +12066,9 @@ var IntentGateway = class {
       }
     }
     amountOutV3 = bestV3AmountOut;
+    if (selectedProtocol === "v3") {
+      return { protocol: "v3", amountOut: amountOutV3, fee: bestV3Fee };
+    }
     let bestV4AmountOut = BigInt(0);
     for (const fee of commonFees) {
       try {
@@ -11864,7 +12083,7 @@ var IntentGateway = class {
           hooks: ADDRESS_ZERO
           // No hooks
         };
-        const quoteResult = (await destClient.simulateContract({
+        const quoteResult = (await client.simulateContract({
           address: v4Quoter,
           abi: UNISWAP_V4_QUOTER_ABI,
           functionName: "quoteExactInputSingle",
@@ -11888,6 +12107,9 @@ var IntentGateway = class {
       }
     }
     amountOutV4 = bestV4AmountOut;
+    if (selectedProtocol === "v4") {
+      return { protocol: "v4", amountOut: amountOutV4, fee: bestV4Fee };
+    }
     if (amountOutV2 === BigInt(0) && amountOutV3 === BigInt(0) && amountOutV4 === BigInt(0)) {
       return {
         protocol: null,