@hyperbridge/sdk 1.3.3 → 1.3.5

package/dist/node/index.d.ts

@@ -941,6 +941,7 @@ interface GetRequestWithStatus extends GenericRequestWithStatuses {
     height: bigint;
     keys: HexString[];
     context: HexString;
+    commitment: HexString;
 }
 interface GetResponseByRequestIdResponse {
     getResponses: {
@@ -1202,7 +1203,7 @@ interface FillerConfig {
      * Policy for determining confirmation requirements
      */
     confirmationPolicy: {
-        getConfirmationBlocks: (chainId: number, amount: bigint) => number;
+        getConfirmationBlocks: (chainId: number, amountUsd: number) => number;
     };
     /**
      * Maximum number of orders to process concurrently
@@ -1852,7 +1853,7 @@ declare function estimateGasForPost(params: {
  * to match the format expected by the IntentGateway contract.
  */
 declare function constructRedeemEscrowRequestBody(order: Order, beneficiary: HexString): HexString;
-declare function fetchPrice(identifier: string, chainId?: number): Promise<number>;
+declare function fetchPrice(identifier: string, chainId?: number, apiKey?: string): Promise<number>;
 /**
  * ERC20 method signatures used for storage slot detection
  */
@@ -2262,14 +2263,14 @@ declare class IndexerClient {
      * @param commitment_hash - Can be commitment
      * @returns Latest status and block metadata of the request
      */
-    queryPostRequest(commitment_hash: string): Promise<PostRequestWithStatus | undefined>;
+    queryPostRequest(commitment_hash: HexString): Promise<PostRequestWithStatus | undefined>;
     /**
      * Queries a request by any of its associated hashes and returns it alongside its statuses
      * Statuses will be one of SOURCE, HYPERBRIDGE_DELIVERED and DESTINATION
      * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
      * @returns Latest status and block metadata of the request
      */
-    queryGetRequest(hash: string): Promise<GetRequestWithStatus | undefined>;
+    queryGetRequest(hash: HexString): Promise<GetRequestWithStatus | undefined>;
     /**
      * Queries the response associated with a specific request ID and returns its commitment
      * @param requestId - The ID of the request to find the associated response for
@@ -2316,7 +2317,31 @@ declare class IndexerClient {
      * @returns Full request data with all inferred status events, including SOURCE_FINALIZED and HYPERBRIDGE_FINALIZED
      * @remarks Unlike queryRequest(), this method adds derived finalization status events by querying state machine updates
      */
-    queryRequestWithStatus(hash: string): Promise<PostRequestWithStatus | undefined>;
+    queryRequestWithStatus(hash: HexString): Promise<PostRequestWithStatus | undefined>;
+    /**
+     * 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
+     */
+    queryGetRequestWithStatus(hash: HexString): Promise<GetRequestWithStatus | undefined>;
+    /**
+     * 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
+     */
+    private addGetRequestFinalityEvents;
     /**
      * Create a Stream of status updates for a post request.
      * Stream ends when either the request reaches the destination or times out.
@@ -2596,7 +2621,7 @@ declare class IntentGateway {
      * @param amountOut - The desired output amount
      * @returns Object containing the best protocol, required input amount, and fee tier (for V3/V4)
      */
-    findBestProtocolWithAmountOut(chain: string, tokenIn: HexString, tokenOut: HexString, amountOut: bigint): Promise<{
+    findBestProtocolWithAmountOut(getQuoteIn: "source" | "dest", tokenIn: HexString, tokenOut: HexString, amountOut: bigint): Promise<{
         protocol: "v2" | "v3" | "v4" | null;
         amountIn: bigint;
         fee?: number;
@@ -2611,7 +2636,7 @@ declare class IntentGateway {
      * @param amountIn - The input amount to swap
      * @returns Object containing the best protocol, expected output amount, and fee tier (for V3/V4)
      */
-    findBestProtocolWithAmountIn(chain: string, tokenIn: HexString, tokenOut: HexString, amountIn: bigint): Promise<{
+    findBestProtocolWithAmountIn(getQuoteIn: "source" | "dest", tokenIn: HexString, tokenOut: HexString, amountIn: bigint, selectedProtocol?: "v2" | "v3" | "v4"): Promise<{
         protocol: "v2" | "v3" | "v4" | null;
         amountOut: bigint;
         fee?: number;

package/dist/node/index.js

@@ -3410,18 +3410,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",
@@ -4420,10 +4420,10 @@ function mapTestnetToMainnet(identifier) {
       return identifier;
   }
 }
-async function fetchPrice(identifier, chainId = 1) {
+async function fetchPrice(identifier, chainId = 1, apiKey) {
   const mappedIdentifier = mapTestnetToMainnet(identifier);
   const network = new ChainConfigService().getCoingeckoId(`EVM-${chainId}`) || "ethereum";
-  const apiKey = typeof process !== "undefined" ? process?.env?.COINGECKO : void 0;
+  apiKey = apiKey || (typeof process !== "undefined" ? process?.env?.COINGECKO : void 0);
   const baseUrl = apiKey ? "https://pro-api.coingecko.com/api/v3" : "https://api.coingecko.com/api/v3";
   const url = mappedIdentifier.startsWith("0x") ? `${baseUrl}/simple/token_price/${network}?contract_addresses=${mappedIdentifier}&vs_currencies=usd` : `${baseUrl}/simple/price?ids=${mappedIdentifier}&vs_currencies=usd`;
   const headers = apiKey ? { "x-cg-pro-api-key": apiKey } : void 0;
@@ -5692,6 +5692,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 +6110,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.
@@ -11402,16 +11517,11 @@ 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 RELAYER_FEE_BPS = 200n;
-    const relayerFeeInSourceFeeToken = postGasEstimateInSourceFeeToken + postGasEstimateInSourceFeeToken * RELAYER_FEE_BPS / 10000n;
+    const postGasEstimateInSourceFeeToken = await this.convertGasToFeeToken(postGasEstimate, "source");
+    const relayerFeeInSourceFeeToken = postGasEstimateInSourceFeeToken + 25n * 10n ** BigInt(sourceChainFeeTokenDecimals - 2);
     const relayerFeeInDestFeeToken = adjustFeeDecimals(
       relayerFeeInSourceFeeToken,
       sourceChainFeeTokenDecimals,
@@ -11466,7 +11576,8 @@ var IntentGateway = class {
     ];
     let destChainFillGas = 0n;
     try {
-      const protocolFeeInNativeToken = await this.quoteNative(postRequest, relayerFeeInDestFeeToken);
+      let protocolFeeInNativeToken = await this.quoteNative(postRequest, relayerFeeInDestFeeToken);
+      protocolFeeInNativeToken = protocolFeeInNativeToken + protocolFeeInNativeToken * 50n / 10000n;
       destChainFillGas = await this.dest.client.estimateContractGas({
         abi: IntentGateway_default.ABI,
         address: intentGatewayAddress,
@@ -11510,9 +11621,10 @@ 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(
@@ -11522,14 +11634,10 @@ var IntentGateway = class {
       sourceChainFeeTokenDecimals
     );
     const totalEstimate = fillGasInSourceFeeToken + protocolFeeInSourceFeeToken + relayerFeeInSourceFeeToken;
-    const SWAP_OPERATIONS_BPS = 2500n;
+    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
-    );
+    const totalNativeTokenAmount = await this.convertFeeTokenToNative(totalFeeTokenAmount, "source");
     return {
       feeTokenAmount: totalFeeTokenAmount,
       nativeTokenAmount: totalNativeTokenAmount,
@@ -11546,16 +11654,19 @@ var IntentGateway = class {
    * @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");
-    }
-    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)));
+  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();
+    const { amountOut } = await this.findBestProtocolWithAmountIn(
+      getQuoteIn,
+      feeToken.address,
+      wethAsset,
+      feeTokenAmount,
+      "v2"
+    );
+    return amountOut;
   }
   /**
    * Converts gas costs to the equivalent amount in the fee token (DAI).
@@ -11567,20 +11678,21 @@ var IntentGateway = class {
    * @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 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)));
+    const evmChainID = `EVM-${client.chain?.id}`;
+    const wethAddr = this[gasEstimateIn].config.getWrappedNativeAssetWithDecimals(evmChainID).asset;
+    const feeToken = await this[gasEstimateIn].getFeeTokenWithDecimals();
+    const { amountOut } = await this.findBestProtocolWithAmountIn(
+      gasEstimateIn,
+      wethAddr,
+      feeToken.address,
+      gasCostInWei,
+      "v2"
+    );
+    return amountOut;
   }
   async quoteNative(postRequest, fee) {
     const dispatchPost = {
@@ -11609,31 +11721,32 @@ var IntentGateway = class {
    * @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 +11760,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 +11813,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",
@@ -11773,37 +11886,41 @@ var IntentGateway = class {
    * @param amountIn - The input amount to swap
    * @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 +11928,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 +11967,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 +11984,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 +12008,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,