@cowprotocol/sdk-bridging 0.3.3-beta.0 → 0.4.0

package/dist/index.js

@@ -122,6 +122,93 @@ function isAppDoc(appData) {
   return typeof appData === "object" && appData !== null && "version" in appData && "metadata" in appData;
 }
 
+// src/const.ts
+var import_sdk_config = require("@cowprotocol/sdk-config");
+var RAW_PROVIDERS_FILES_PATH = `${import_sdk_config.RAW_FILES_PATH}/src/bridging/providers`;
+var DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION = 24e4;
+var DEFAULT_EXTRA_GAS_FOR_HOOK_ESTIMATION = 2e5;
+var COW_SHED_PROXY_CREATION_GAS = 36e4;
+var DEFAULT_EXTRA_GAS_PROXY_CREATION = 4e5;
+var HOOK_DAPP_BRIDGE_PROVIDER_PREFIX = "cow-sdk://bridging/providers";
+
+// src/BridgingSdk/findBridgeProviderFromHook.ts
+function findBridgeProviderFromHook(fullAppData, providers) {
+  const postHooks = getPostHooks(fullAppData);
+  const bridgingHook = postHooks.find((hook) => {
+    return hook.dappId?.startsWith(HOOK_DAPP_BRIDGE_PROVIDER_PREFIX);
+  });
+  if (!bridgingHook) {
+    return void 0;
+  }
+  const bridgeProviderDappId = bridgingHook.dappId;
+  return providers.find((provider) => provider.info.dappId === bridgeProviderDappId);
+}
+
+// src/BridgingSdk/getCrossChainOrder.ts
+async function getCrossChainOrder(params) {
+  const { chainId, orderId, orderBookApi, providers, env } = params;
+  const chainContext = { chainId, env };
+  const order = await orderBookApi.getOrder(orderId, chainContext);
+  const provider = order.fullAppData && findBridgeProviderFromHook(order.fullAppData, providers);
+  if (!provider) {
+    throw new BridgeOrderParsingError(
+      `Unknown Bridge provider in order ${order.uid}. Add provider to the SDK config to be able to decode the order`
+    );
+  }
+  const trades = await orderBookApi.getTrades({ orderUid: order.uid }, chainContext);
+  if (trades.length > 0) {
+    const firstTrade = trades[0];
+    const tradeTxHash = firstTrade?.txHash;
+    if (!tradeTxHash) {
+      throw new BridgeOrderParsingError(
+        `No tx hash found for order ${orderId} . First trade, with log index ${firstTrade?.logIndex}`
+      );
+    }
+    const { params: bridgingParams, status: statusResult } = await provider.getBridgingParams(chainId, orderId, tradeTxHash) || {};
+    if (!bridgingParams || !statusResult) {
+      throw new BridgeOrderParsingError(`Bridging params cannot be derived from transaction: ${tradeTxHash}`);
+    }
+    const state = {
+      provider,
+      chainId,
+      order,
+      statusResult: {
+        status: "unknown" /* UNKNOWN */
+      },
+      bridgingParams,
+      tradeTxHash
+    };
+    try {
+      const explorerUrl = provider.getExplorerUrl(bridgingParams.bridgingId);
+      return {
+        ...state,
+        statusResult,
+        explorerUrl
+      };
+    } catch (e) {
+      console.error("Cannot get bridging status", e);
+      return state;
+    }
+  }
+  return null;
+}
+
+// src/BridgingSdk/BridgingSdk.ts
+var import_sdk_trading2 = require("@cowprotocol/sdk-trading");
+var import_sdk_order_book2 = require("@cowprotocol/sdk-order-book");
+var import_sdk_config2 = require("@cowprotocol/sdk-config");
+var import_sdk_common4 = require("@cowprotocol/sdk-common");
+
+// src/BridgingSdk/helpers.ts
+var getCacheKey = ({
+  id,
+  buyChainId,
+  sellChainId = "noSellChainID",
+  tokenAddress = "noTokenAddress"
+}) => {
+  return `${id}-${buyChainId}-${sellChainId}-${tokenAddress.toLowerCase()}`;
+};
+
 // src/BridgingSdk/getQuoteWithoutBridge.ts
 var import_sdk_common = require("@cowprotocol/sdk-common");
 function getQuoteWithoutBridge(params) {
@@ -141,6 +228,8 @@ function getQuoteWithoutBridge(params) {
 
 // src/BridgingSdk/getQuoteWithBridge.ts
 var import_sdk_trading = require("@cowprotocol/sdk-trading");
+var import_sdk_common3 = require("@cowprotocol/sdk-common");
+var import_sdk_order_book = require("@cowprotocol/sdk-order-book");
 
 // src/BridgingSdk/getBridgeSignedHook.ts
 var import_sdk_common2 = require("@cowprotocol/sdk-common");
@@ -168,19 +257,6 @@ async function getBridgeSignedHook(bridgeRequest, { provider, signer, hookGasLim
   };
 }
 
-// src/const.ts
-var import_sdk_config = require("@cowprotocol/sdk-config");
-var RAW_PROVIDERS_FILES_PATH = `${import_sdk_config.RAW_FILES_PATH}/src/bridging/providers`;
-var DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION = 24e4;
-var DEFAULT_EXTRA_GAS_FOR_HOOK_ESTIMATION = 2e5;
-var COW_SHED_PROXY_CREATION_GAS = 36e4;
-var DEFAULT_EXTRA_GAS_PROXY_CREATION = 4e5;
-var HOOK_DAPP_BRIDGE_PROVIDER_PREFIX = "cow-sdk://bridging/providers";
-
-// src/BridgingSdk/getQuoteWithBridge.ts
-var import_sdk_order_book = require("@cowprotocol/sdk-order-book");
-var import_sdk_common3 = require("@cowprotocol/sdk-common");
-
 // src/hooks/utils.ts
 function getHookMockForCostEstimation(gasLimit) {
   return {
@@ -214,7 +290,8 @@ async function getQuoteWithBridge(params) {
   );
   const bridgeRequestWithoutAmount = await getBaseBridgeQuoteRequest({
     swapAndBridgeRequest,
-    provider
+    provider,
+    intermediateTokensCache: params.intermediateTokensCache
   });
   const hookEstimatedGasLimit = await provider.getGasLimitEstimationForHook(bridgeRequestWithoutAmount);
   const mockedHook = getHookMockForCostEstimation(hookEstimatedGasLimit);
@@ -256,7 +333,7 @@ async function getQuoteWithBridge(params) {
   });
   const intermediateTokenAmount = swapResult.amountsAndCosts.afterSlippage.buyAmount;
   (0, import_sdk_common3.log)(
-    `Expected to receive ${intermediateTokenAmount} of the intermediate token (${(intermediateTokenAmount / BigInt(10 ** intermediaryTokenDecimals)).toString()} formatted)`
+    `Expected to receive ${intermediateTokenAmount} of the intermediate token (${(intermediateTokenAmount / 10n ** BigInt(intermediaryTokenDecimals)).toString()} formatted)`
   );
   async function signHooksAndSetSwapResult(signer2, hookGasLimit, advancedSettings2) {
     const appDataOverride = advancedSettings2?.appData;
@@ -350,13 +427,26 @@ async function getQuoteWithBridge(params) {
   };
 }
 async function getBaseBridgeQuoteRequest(params) {
-  const { provider, swapAndBridgeRequest: quoteBridgeRequest } = params;
-  const intermediateTokens = await provider.getIntermediateTokens(quoteBridgeRequest);
+  const { provider, swapAndBridgeRequest: quoteBridgeRequest, intermediateTokensCache } = params;
+  let intermediateTokens = [];
+  const cacheKey = getCacheKey({
+    id: provider.info.dappId,
+    buyChainId: quoteBridgeRequest.buyTokenChainId.toString(),
+    sellChainId: quoteBridgeRequest.sellTokenChainId.toString(),
+    tokenAddress: quoteBridgeRequest.buyTokenAddress
+  });
+  const cached = intermediateTokensCache?.get(cacheKey);
+  if (cached) {
+    intermediateTokens = cached;
+  } else {
+    intermediateTokens = await provider.getIntermediateTokens(quoteBridgeRequest);
+    intermediateTokensCache?.set(cacheKey, intermediateTokens);
+  }
   if (intermediateTokens.length === 0) {
     throw new BridgeProviderQuoteError("NO_INTERMEDIATE_TOKENS" /* NO_INTERMEDIATE_TOKENS */);
   }
   const intermediateToken = intermediateTokens[0];
-  (0, import_sdk_common3.log)(`Using ${intermediateToken} as intermediate tokens`);
+  (0, import_sdk_common3.log)(`Using ${intermediateToken?.name ?? intermediateToken?.address} as intermediate tokens`);
   if (!intermediateToken) {
     throw new BridgeProviderQuoteError("NO_INTERMEDIATE_TOKENS" /* NO_INTERMEDIATE_TOKENS */, { intermediateTokens });
   }
@@ -404,82 +494,333 @@ async function getBridgeResult(context) {
   return { bridgeResult, bridgeHook, appDataInfo };
 }
 
-// src/BridgingSdk/findBridgeProviderFromHook.ts
-function findBridgeProviderFromHook(fullAppData, providers) {
-  const postHooks = getPostHooks(fullAppData);
-  const bridgingHook = postHooks.find((hook) => {
-    return hook.dappId?.startsWith(HOOK_DAPP_BRIDGE_PROVIDER_PREFIX);
-  });
-  if (!bridgingHook) {
-    return void 0;
+// src/BridgingSdk/strategies/QuoteStrategy.ts
+var QuoteStrategy = class {
+  constructor(intermediateTokensCache) {
+    this.intermediateTokensCache = intermediateTokensCache;
   }
-  const bridgeProviderDappId = bridgingHook.dappId;
-  return providers.find((provider) => provider.info.dappId === bridgeProviderDappId);
-}
+};
+var BaseSingleQuoteStrategy = class extends QuoteStrategy {
+};
+var BaseMultiQuoteStrategy = class extends QuoteStrategy {
+};
+var BaseBestQuoteStrategy = class extends QuoteStrategy {
+};
 
-// src/BridgingSdk/getCrossChainOrder.ts
-async function getCrossChainOrder(params) {
-  const { chainId, orderId, orderBookApi, providers, env } = params;
-  const chainContext = { chainId, env };
-  const order = await orderBookApi.getOrder(orderId, chainContext);
-  const provider = order.fullAppData && findBridgeProviderFromHook(order.fullAppData, providers);
-  if (!provider) {
-    throw new BridgeOrderParsingError(
-      `Unknown Bridge provider in order ${order.uid}. Add provider to the SDK config to be able to decode the order`
+// src/BridgingSdk/strategies/SingleQuoteStrategy.ts
+var SingleQuoteStrategy = class extends BaseSingleQuoteStrategy {
+  strategyName = "SingleQuoteStrategy";
+  constructor(intermediateTokensCache) {
+    super(intermediateTokensCache);
+  }
+  async execute(request, config) {
+    const { quoteBridgeRequest, advancedSettings } = request;
+    const { sellTokenChainId, buyTokenChainId } = quoteBridgeRequest;
+    const { tradingSdk, providers } = config;
+    if (sellTokenChainId !== buyTokenChainId) {
+      const provider = providers[0];
+      if (!provider) {
+        throw new Error("No provider found for cross-chain swap");
+      }
+      const baseParams = {
+        swapAndBridgeRequest: quoteBridgeRequest,
+        advancedSettings,
+        tradingSdk,
+        provider,
+        bridgeHookSigner: advancedSettings?.quoteSigner
+      };
+      const request2 = this.intermediateTokensCache ? {
+        ...baseParams,
+        intermediateTokensCache: this.intermediateTokensCache
+      } : baseParams;
+      return getQuoteWithBridge(request2);
+    } else {
+      return getQuoteWithoutBridge({
+        quoteBridgeRequest,
+        advancedSettings,
+        tradingSdk
+      });
+    }
+  }
+};
+
+// src/BridgingSdk/utils.ts
+function validateCrossChainRequest(sellTokenChainId, buyTokenChainId) {
+  if (sellTokenChainId === buyTokenChainId) {
+    throw new BridgeProviderError(
+      "getMultiQuotes() and getBestQuote() are only for cross-chain bridging. For single-chain swaps, use getQuote() instead.",
+      { sellTokenChainId, buyTokenChainId }
     );
   }
-  const trades = await orderBookApi.getTrades({ orderUid: order.uid }, chainContext);
-  if (trades.length > 0) {
-    const firstTrade = trades[0];
-    const tradeTxHash = firstTrade?.txHash;
-    if (!tradeTxHash) {
-      throw new BridgeOrderParsingError(
-        `No tx hash found for order ${orderId} . First trade, with log index ${firstTrade?.logIndex}`
+}
+function createBridgeQuoteTimeoutPromise(timeoutMs, prefix) {
+  return new Promise((_, reject) => {
+    setTimeout(() => {
+      reject(new BridgeProviderError(`${prefix} timeout after ${timeoutMs}ms`, {}));
+    }, timeoutMs);
+  });
+}
+function safeCallProgressiveCallback(onQuoteResult, result) {
+  if (!onQuoteResult) {
+    return;
+  }
+  try {
+    onQuoteResult(result);
+  } catch (callbackError) {
+    console.warn("Error in onQuoteResult callback:", callbackError);
+  }
+}
+function fillTimeoutResults(results, providersToQuery) {
+  for (let i = 0; i < providersToQuery.length; i++) {
+    const provider = providersToQuery[i];
+    if (!results[i] && provider) {
+      results[i] = {
+        providerDappId: provider.info.dappId,
+        quote: null,
+        error: new BridgeProviderError("Provider request timed out", {})
+      };
+    }
+  }
+}
+async function executeProviderQuotes(promises, timeout, config) {
+  try {
+    await Promise.race([
+      Promise.allSettled(promises),
+      createBridgeQuoteTimeoutPromise(timeout, `Multi-quote with ${config.providers.length}`)
+    ]);
+  } catch {
+    console.warn("getMultiQuotes timeout occurred, returning partial results");
+  }
+}
+function isBetterQuote(quote1, quote2) {
+  if (!quote2 || !quote2.quote) {
+    return !!quote1.quote;
+  }
+  if (!quote1.quote) {
+    return false;
+  }
+  const quote1BuyAmount = quote1.quote.bridge.amountsAndCosts.afterSlippage.buyAmount;
+  const quote2BuyAmount = quote2.quote.bridge.amountsAndCosts.afterSlippage.buyAmount;
+  return quote1BuyAmount > quote2BuyAmount;
+}
+function safeCallBestQuoteCallback(onQuoteResult, result) {
+  if (!onQuoteResult) {
+    return;
+  }
+  try {
+    onQuoteResult(result);
+  } catch (callbackError) {
+    console.warn("Error in onQuoteResult callback:", callbackError);
+  }
+}
+function resolveProvidersToQuery(providerDappIds, providers) {
+  if (!providerDappIds) {
+    return providers;
+  }
+  return providerDappIds.map((dappId) => {
+    const provider = providers.find((p) => p.info.dappId === dappId);
+    if (!provider) {
+      throw new BridgeProviderError(
+        `Provider with dappId '${dappId}' not found. Available providers: ${providers.map((p) => p.info.dappId).join(", ")}`,
+        { providers }
       );
     }
-    const { params: bridgingParams, status: statusResult } = await provider.getBridgingParams(chainId, orderId, tradeTxHash) || {};
-    if (!bridgingParams || !statusResult) {
-      throw new BridgeOrderParsingError(`Bridging params cannot be derived from transaction: ${tradeTxHash}`);
+    return provider;
+  });
+}
+
+// src/BridgingSdk/strategies/MultiQuoteStrategy.ts
+var DEFAULT_TOTAL_TIMEOUT_MS = 4e4;
+var DEFAULT_PROVIDER_TIMEOUT_MS = 2e4;
+var MultiQuoteStrategy = class extends BaseMultiQuoteStrategy {
+  strategyName = "MultiQuoteStrategy";
+  constructor(intermediateTokensCache) {
+    super(intermediateTokensCache);
+  }
+  async execute(request, config) {
+    const { quoteBridgeRequest, providerDappIds, advancedSettings, options } = request;
+    const { sellTokenChainId, buyTokenChainId } = quoteBridgeRequest;
+    validateCrossChainRequest(sellTokenChainId, buyTokenChainId);
+    const providersToQuery = resolveProvidersToQuery(providerDappIds, config.providers);
+    const {
+      onQuoteResult,
+      totalTimeout = DEFAULT_TOTAL_TIMEOUT_MS,
+      providerTimeout = DEFAULT_PROVIDER_TIMEOUT_MS
+    } = options || {};
+    const results = [];
+    const promises = [];
+    for (let i = 0; i < providersToQuery.length; i++) {
+      const provider = providersToQuery[i];
+      if (!provider) {
+        continue;
+      }
+      const context = {
+        provider,
+        quoteBridgeRequest,
+        advancedSettings,
+        providerTimeout,
+        onQuoteResult,
+        results,
+        index: i
+      };
+      const promise = this.createProviderQuotePromise(context, config);
+      promises.push(promise);
     }
-    const state = {
-      provider,
-      chainId,
-      order,
-      statusResult: {
-        status: "unknown" /* UNKNOWN */
-      },
-      bridgingParams,
-      tradeTxHash
-    };
-    try {
-      const explorerUrl = provider.getExplorerUrl(bridgingParams.bridgingId);
-      return {
-        ...state,
-        statusResult,
-        explorerUrl
+    await executeProviderQuotes(promises, totalTimeout, config);
+    fillTimeoutResults(results, providersToQuery);
+    results.sort((a, b) => {
+      if (isBetterQuote(a, b))
+        return -1;
+      if (isBetterQuote(b, a))
+        return 1;
+      return 0;
+    });
+    return results;
+  }
+  createProviderQuotePromise(context, config) {
+    const { provider, quoteBridgeRequest, advancedSettings, providerTimeout, onQuoteResult, results, index } = context;
+    return (async () => {
+      try {
+        const baseParams = {
+          swapAndBridgeRequest: quoteBridgeRequest,
+          advancedSettings,
+          tradingSdk: config.tradingSdk,
+          provider,
+          bridgeHookSigner: advancedSettings?.quoteSigner
+        };
+        const request = this.intermediateTokensCache ? {
+          ...baseParams,
+          intermediateTokensCache: this.intermediateTokensCache
+        } : baseParams;
+        const quote = await Promise.race([
+          getQuoteWithBridge(request),
+          createBridgeQuoteTimeoutPromise(providerTimeout, `Provider ${provider.info.dappId}`)
+        ]);
+        const result = {
+          providerDappId: provider.info.dappId,
+          quote,
+          error: void 0
+        };
+        results[index] = result;
+        safeCallProgressiveCallback(onQuoteResult, result);
+      } catch (error) {
+        const result = {
+          providerDappId: provider.info.dappId,
+          quote: null,
+          error: error instanceof Error ? error : new BridgeProviderError(String(error), {})
+        };
+        results[index] = result;
+        safeCallProgressiveCallback(onQuoteResult, result);
+      }
+    })();
+  }
+};
+
+// src/BridgingSdk/strategies/BestQuoteStrategy.ts
+var DEFAULT_TOTAL_TIMEOUT_MS2 = 4e4;
+var DEFAULT_PROVIDER_TIMEOUT_MS2 = 2e4;
+var BestQuoteStrategy = class extends BaseBestQuoteStrategy {
+  strategyName = "BestQuoteStrategy";
+  constructor(intermediateTokensCache) {
+    super(intermediateTokensCache);
+  }
+  async execute(request, config) {
+    const { quoteBridgeRequest, providerDappIds, advancedSettings, options } = request;
+    const { sellTokenChainId, buyTokenChainId } = quoteBridgeRequest;
+    validateCrossChainRequest(sellTokenChainId, buyTokenChainId);
+    const providersToQuery = resolveProvidersToQuery(providerDappIds, config.providers);
+    const {
+      onQuoteResult,
+      totalTimeout = DEFAULT_TOTAL_TIMEOUT_MS2,
+      providerTimeout = DEFAULT_PROVIDER_TIMEOUT_MS2
+    } = options || {};
+    const bestResult = { current: null };
+    const firstError = { current: null };
+    const promises = [];
+    for (const provider of providersToQuery) {
+      const context = {
+        provider,
+        quoteBridgeRequest,
+        advancedSettings,
+        providerTimeout,
+        onQuoteResult,
+        bestResult,
+        firstError
       };
-    } catch (e) {
-      console.error("Cannot get bridging status", e);
-      return state;
+      const promise = this.createBestQuoteProviderPromise(context, config);
+      promises.push(promise);
     }
+    await executeProviderQuotes(promises, totalTimeout, config);
+    return bestResult.current || firstError.current;
   }
-  return null;
+  createBestQuoteProviderPromise(context, config) {
+    const { provider, quoteBridgeRequest, advancedSettings, providerTimeout, onQuoteResult, bestResult, firstError } = context;
+    return (async () => {
+      try {
+        const baseParams = {
+          swapAndBridgeRequest: quoteBridgeRequest,
+          advancedSettings,
+          tradingSdk: config.tradingSdk,
+          provider,
+          bridgeHookSigner: advancedSettings?.quoteSigner
+        };
+        const request = this.intermediateTokensCache ? {
+          ...baseParams,
+          intermediateTokensCache: this.intermediateTokensCache
+        } : baseParams;
+        const quote = await Promise.race([
+          getQuoteWithBridge(request),
+          createBridgeQuoteTimeoutPromise(providerTimeout, `Provider ${provider.info.dappId}`)
+        ]);
+        const result = {
+          providerDappId: provider.info.dappId,
+          quote,
+          error: void 0
+        };
+        if (isBetterQuote(result, bestResult.current)) {
+          bestResult.current = result;
+          safeCallBestQuoteCallback(onQuoteResult, result);
+        }
+      } catch (error) {
+        const errorResult = {
+          providerDappId: provider.info.dappId,
+          quote: null,
+          error: error instanceof Error ? error : new BridgeProviderError(String(error), {})
+        };
+        if (!firstError.current) {
+          firstError.current = errorResult;
+        }
+      }
+    })();
+  }
+};
+
+// src/BridgingSdk/strategies/createStrategies.ts
+function createStrategies(intermediateTokensCache) {
+  return {
+    singleQuoteStrategy: new SingleQuoteStrategy(intermediateTokensCache),
+    multiQuoteStrategy: new MultiQuoteStrategy(intermediateTokensCache),
+    bestQuoteStrategy: new BestQuoteStrategy(intermediateTokensCache)
+  };
 }
 
 // src/BridgingSdk/BridgingSdk.ts
-var import_sdk_trading2 = require("@cowprotocol/sdk-trading");
-var import_sdk_order_book2 = require("@cowprotocol/sdk-order-book");
-var import_sdk_config2 = require("@cowprotocol/sdk-config");
-var import_sdk_common4 = require("@cowprotocol/sdk-common");
+var DEFAULT_CACHE_CONFIG = {
+  enabled: true,
+  intermediateTokensTtl: 5 * 60 * 1e3,
+  // 5 minutes
+  buyTokensTtl: 2 * 60 * 1e3
+  // 2 minutes
+};
 var BridgingSdk = class {
   constructor(options, adapter) {
     this.options = options;
     if (adapter) {
       (0, import_sdk_common4.setGlobalAdapter)(adapter);
     }
-    const { providers, ...restOptions } = options;
-    if (!providers || providers.length !== 1) {
-      throw new Error("Current implementation only supports a single bridge provider");
+    const { providers, cacheConfig, ...restOptions } = options;
+    if (!providers || providers.length === 0) {
+      throw new Error("At least one bridge provider is required");
     }
     if (options.enableLogging !== void 0) {
       (0, import_sdk_common4.enableLogging)(options.enableLogging);
@@ -492,8 +833,31 @@ var BridgingSdk = class {
       tradingSdk,
       orderBookApi
     };
+    this.cacheConfig = { ...DEFAULT_CACHE_CONFIG, ...cacheConfig };
+    this.intermediateTokensCache = new import_sdk_common4.TTLCache(
+      "bridging-intermediate-tokens",
+      this.cacheConfig.enabled,
+      this.cacheConfig.intermediateTokensTtl
+    );
+    this.buyTokensCache = new import_sdk_common4.TTLCache(
+      "bridging-buy-tokens",
+      this.cacheConfig.enabled,
+      this.cacheConfig.buyTokensTtl
+    );
+    const { singleQuoteStrategy, multiQuoteStrategy, bestQuoteStrategy } = createStrategies(
+      this.cacheConfig.enabled ? this.intermediateTokensCache : void 0
+    );
+    this.singleQuoteStrategy = singleQuoteStrategy;
+    this.multiQuoteStrategy = multiQuoteStrategy;
+    this.bestQuoteStrategy = bestQuoteStrategy;
   }
   config;
+  cacheConfig;
+  intermediateTokensCache;
+  buyTokensCache;
+  singleQuoteStrategy;
+  multiQuoteStrategy;
+  bestQuoteStrategy;
   get provider() {
     const { providers } = this.config;
     if (!providers[0]) {
@@ -525,7 +889,22 @@ var BridgingSdk = class {
      * @param params
      */
   async getBuyTokens(params) {
-    return this.provider.getBuyTokens(params);
+    const providerId = this.provider.info.dappId;
+    const cacheKey = getCacheKey({
+      id: providerId,
+      buyChainId: params.buyChainId.toString(),
+      sellChainId: params.sellChainId?.toString(),
+      tokenAddress: params.sellTokenAddress
+    });
+    const cached = this.cacheConfig.enabled && this.buyTokensCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const result = await this.provider.getBuyTokens(params);
+    if (this.cacheConfig.enabled) {
+      this.buyTokensCache.set(cacheKey, result);
+    }
+    return result;
   }
   /**
    * Get quote details, including a callback function to post the order on-chain.
@@ -543,23 +922,49 @@ var BridgingSdk = class {
    * @throws Error if no path is found
    */
   async getQuote(quoteBridgeRequest, advancedSettings) {
-    const { sellTokenChainId, buyTokenChainId } = quoteBridgeRequest;
-    const tradingSdk = this.config.tradingSdk;
-    if (sellTokenChainId !== buyTokenChainId) {
-      return getQuoteWithBridge({
-        swapAndBridgeRequest: quoteBridgeRequest,
-        advancedSettings,
-        tradingSdk,
-        provider: this.provider,
-        bridgeHookSigner: advancedSettings?.quoteSigner
-      });
-    } else {
-      return getQuoteWithoutBridge({
+    return this.singleQuoteStrategy.execute(
+      {
         quoteBridgeRequest,
-        advancedSettings,
-        tradingSdk
-      });
-    }
+        advancedSettings
+      },
+      this.config
+    );
+  }
+  /**
+   * Get quotes from multiple bridge providers in parallel with progressive results.
+   *
+   * This method is specifically for cross-chain bridging quotes. For single-chain swaps, use getQuote() instead.
+   *
+   * Features:
+   * - Progressive results: Use the `onQuoteResult` callback to receive quotes as soon as each provider responds
+   * - Timeout support: Configure maximum wait time for all providers and individual provider timeouts
+   * - Parallel execution: All providers are queried simultaneously for best performance
+   *
+   * @param request - The multi-quote request containing quote parameters, provider dappIds, and options
+   * @returns Array of results, one for each provider (successful quotes or errors)
+   * @throws Error if the request is for a single-chain swap (sellTokenChainId === buyTokenChainId)
+   * ```
+   */
+  async getMultiQuotes(request) {
+    return this.multiQuoteStrategy.execute(request, this.config);
+  }
+  /**
+   * Get the best quote from multiple bridge providers with progressive updates.
+   *
+   * This method is specifically for cross-chain bridging quotes. For single-chain swaps, use getQuote() instead.
+   *
+   * Features:
+   * - Returns only the best quote based on buyAmount after slippage
+   * - Progressive updates: Use the `onQuoteResult` callback to receive updates whenever a better quote is found
+   * - Timeout support: Configure maximum wait time for all providers and individual provider timeouts
+   * - Parallel execution: All providers are queried simultaneously for best performance
+   *
+   * @param request - The best quote request containing quote parameters, provider dappIds, and options
+   * @returns The best quote result found, or null if no successful quotes were obtained
+   * @throws Error if the request is for a single-chain swap (sellTokenChainId === buyTokenChainId)
+   */
+  async getBestQuote(request) {
+    return this.bestQuoteStrategy.execute(request, this.config);
   }
   async getOrder(params) {
     const { orderBookApi } = this.config;
@@ -578,6 +983,32 @@ var BridgingSdk = class {
   getProviderFromAppData(fullAppData) {
     return findBridgeProviderFromHook(fullAppData, this.getProviders());
   }
+  /**
+   * Clear all caches. Useful for testing and debugging.
+   */
+  clearCache() {
+    this.intermediateTokensCache.clear();
+    this.buyTokensCache.clear();
+  }
+  /**
+   * Clean up expired cache entries. Useful for maintenance.
+   */
+  cleanupExpiredCache() {
+    this.intermediateTokensCache.cleanup();
+    this.buyTokensCache.cleanup();
+  }
+  /**
+   * Get cache statistics for debugging.
+   */
+  getCacheStats() {
+    return {
+      intermediateTokens: this.intermediateTokensCache.size(),
+      buyTokens: this.buyTokensCache.size()
+    };
+  }
+  getProviderByDappId(dappId) {
+    return this.config.providers.find((provider) => provider.info.dappId === dappId);
+  }
 };
 
 // src/providers/across/AcrossApi.ts
@@ -2924,8 +3355,8 @@ var AcrossBridgeProvider = class {
       status: await this.getStatus(params.bridgingId, chainId)
     };
   }
-  getExplorerUrl(bridgingId) {
-    return `https://app.across.to/transactions/${bridgingId}`;
+  getExplorerUrl(_) {
+    return `https://app.across.to/transactions`;
   }
   async getStatus(bridgingId, originChainId) {
     const depositStatus = await this.api.getDepositStatus({
@@ -3431,9 +3862,13 @@ var BUNGEE_APPROVE_AND_BRIDGE_V1_ABI = [
 
 // src/providers/bungee/BungeeApi.ts
 var import_sdk_common12 = require("@cowprotocol/sdk-common");
+
+// src/providers/bungee/consts.ts
+var BUNGEE_API_PATH = "/api/v1/bungee";
+var BUNGEE_MANUAL_API_PATH = "/api/v1/bungee-manual";
 var BUNGEE_BASE_URL = "https://public-backend.bungee.exchange";
-var BUNGEE_API_URL = `${BUNGEE_BASE_URL}/api/v1/bungee`;
-var BUNGEE_MANUAL_API_URL = `${BUNGEE_BASE_URL}/api/v1/bungee-manual`;
+var BUNGEE_API_URL = `${BUNGEE_BASE_URL}${BUNGEE_API_PATH}`;
+var BUNGEE_MANUAL_API_URL = `${BUNGEE_BASE_URL}${BUNGEE_MANUAL_API_PATH}`;
 var BUNGEE_EVENTS_API_URL = "https://microservices.socket.tech/loki";
 var ACROSS_API_URL2 = "https://app.across.to/api";
 var SUPPORTED_BRIDGES = ["across", "cctp", "gnosis-native-bridge"];
@@ -3443,16 +3878,98 @@ var errorMessageMap = {
   across: "Across Api Error",
   "bungee-manual": "Bungee Manual Api Error"
 };
+var DEFAULT_API_OPTIONS = {
+  apiBaseUrl: BUNGEE_API_URL,
+  eventsApiBaseUrl: BUNGEE_EVENTS_API_URL,
+  acrossApiBaseUrl: ACROSS_API_URL2,
+  manualApiBaseUrl: BUNGEE_MANUAL_API_URL
+};
+var BUNGEE_API_FALLBACK_TIMEOUT = 3e5;
+
+// src/providers/bungee/apiUtils.ts
+function isValidQuoteResponse(response) {
+  if (typeof response !== "object" || response === null) {
+    return false;
+  }
+  const resp = response;
+  if (!("success" in resp) || !("statusCode" in resp) || !("result" in resp) || typeof resp.success !== "boolean" || typeof resp.statusCode !== "number") {
+    return false;
+  }
+  const result = resp.result;
+  if (typeof result !== "object" || result === null) {
+    return false;
+  }
+  const res = result;
+  if (!("originChainId" in res) || !("destinationChainId" in res) || !("userAddress" in res) || !("receiverAddress" in res) || !("manualRoutes" in res) || !Array.isArray(res.manualRoutes)) {
+    return false;
+  }
+  return res.manualRoutes.every((route) => {
+    if (typeof route !== "object" || route === null) {
+      return false;
+    }
+    const r = route;
+    if (!("routeDetails" in r) || typeof r.routeDetails !== "object" || r.routeDetails === null) {
+      return false;
+    }
+    if (!("routeFee" in r.routeDetails)) {
+      return false;
+    }
+    const routeFee = r.routeDetails.routeFee;
+    if (typeof routeFee !== "object" || routeFee === null) {
+      return false;
+    }
+    if (!("amount" in routeFee)) {
+      return false;
+    }
+    return "quoteId" in r && "quoteExpiry" in r && "output" in r && "gasFee" in r && "slippage" in r && "estimatedTime" in r && "routeDetails" in r;
+  });
+}
+function isValidBungeeEventsResponse(response) {
+  if (typeof response !== "object" || response === null) {
+    return false;
+  }
+  const resp = response;
+  if (!("success" in resp) || !("result" in resp) || typeof resp.success !== "boolean" || !Array.isArray(resp.result)) {
+    return false;
+  }
+  return resp.result.every((event) => {
+    if (typeof event !== "object" || event === null) {
+      return false;
+    }
+    const e = event;
+    return "identifier" in e && "bridgeName" in e && "fromChainId" in e && "isCowswapTrade" in e && "orderId" in e && // 'recipient' in e &&
+    "sender" in e && "srcTxStatus" in e && "destTxStatus" in e;
+  });
+}
+function isValidAcrossStatusResponse(response) {
+  if (typeof response !== "object" || response === null) {
+    return false;
+  }
+  const resp = response;
+  if (!("status" in resp)) {
+    return false;
+  }
+  return true;
+}
+function isInfrastructureError(status) {
+  return status >= 500 || status === 429;
+}
+function isClientFetchError(error) {
+  return error instanceof TypeError || error instanceof Error && error.message?.includes("fetch");
+}
+function resolveApiEndpointFromOptions(key, options, useFallback, customUrl) {
+  return useFallback ? DEFAULT_API_OPTIONS[key] : customUrl || options[key] || DEFAULT_API_OPTIONS[key];
+}
+
+// src/providers/bungee/BungeeApi.ts
 var BungeeApi = class {
-  constructor(options = {
-    apiBaseUrl: BUNGEE_API_URL,
-    eventsApiBaseUrl: BUNGEE_EVENTS_API_URL,
-    acrossApiBaseUrl: ACROSS_API_URL2,
-    includeBridges: SUPPORTED_BRIDGES
-  }) {
+  constructor(options = DEFAULT_API_OPTIONS) {
     this.options = options;
     this.validateBridges(this.getSupportedBridges());
+    this.fallbackTimeoutMs = this.options.fallbackTimeoutMs ?? BUNGEE_API_FALLBACK_TIMEOUT;
   }
+  fallbackStates = /* @__PURE__ */ new Map();
+  fallbackTimeoutMs;
   // TODO: why do we need options.includeBridges then? Practically, you cannot add more bridges dynamically
   validateBridges(includeBridges) {
     if (includeBridges?.some((bridge) => !SUPPORTED_BRIDGES.includes(bridge))) {
@@ -3680,100 +4197,94 @@ var BungeeApi = class {
   getSupportedBridges(bridges) {
     return bridges ?? this.options.includeBridges ?? SUPPORTED_BRIDGES;
   }
+  isBungeeApi(apiType) {
+    return apiType === "bungee" || apiType === "bungee-manual";
+  }
+  shouldAddApiKey(apiType) {
+    return this.isBungeeApi(apiType) && !!this.options.apiKey && !!this.options.customApiBaseUrl;
+  }
+  shouldUseFallback(apiType) {
+    const fallbackState = this.fallbackStates.get(apiType);
+    if (!fallbackState)
+      return false;
+    const now = Date.now();
+    if (now > fallbackState.fallbackExpiresAt) {
+      this.fallbackStates.delete(apiType);
+      return false;
+    }
+    return fallbackState.isUsingFallback;
+  }
+  enableFallback(apiType) {
+    const now = Date.now();
+    this.fallbackStates.set(apiType, {
+      isUsingFallback: true,
+      fallbackExpiresAt: now + this.fallbackTimeoutMs
+    });
+  }
   shouldAddAffiliate(apiType, baseUrl) {
-    const isBungeeApi = apiType === "bungee" || apiType === "bungee-manual";
-    return !baseUrl.includes(BUNGEE_BASE_URL) && isBungeeApi;
+    if (!this.isBungeeApi(apiType))
+      return false;
+    const defaultHost = new URL(BUNGEE_BASE_URL).host;
+    const baseHost = new URL(baseUrl).host;
+    return this.shouldAddApiKey(apiType) || baseHost !== defaultHost;
   }
   async makeApiCall(apiType, path, params, isValidResponse) {
+    const useFallback = this.shouldUseFallback(apiType);
+    const customApiBaseUrl = this.options.apiKey ? this.options.customApiBaseUrl : void 0;
     const baseUrlMap = {
-      bungee: this.options.apiBaseUrl || BUNGEE_API_URL,
-      events: this.options.eventsApiBaseUrl || BUNGEE_EVENTS_API_URL,
-      across: this.options.acrossApiBaseUrl || ACROSS_API_URL2,
-      "bungee-manual": this.options.manualApiBaseUrl || BUNGEE_MANUAL_API_URL
+      bungee: resolveApiEndpointFromOptions(
+        "apiBaseUrl",
+        this.options,
+        useFallback,
+        customApiBaseUrl ? `${customApiBaseUrl}${BUNGEE_API_PATH}` : void 0
+      ),
+      "bungee-manual": resolveApiEndpointFromOptions(
+        "manualApiBaseUrl",
+        this.options,
+        useFallback,
+        customApiBaseUrl ? `${customApiBaseUrl}${BUNGEE_MANUAL_API_PATH}` : void 0
+      ),
+      events: resolveApiEndpointFromOptions("eventsApiBaseUrl", this.options, useFallback),
+      across: resolveApiEndpointFromOptions("acrossApiBaseUrl", this.options, useFallback)
     };
     const baseUrl = baseUrlMap[apiType];
     const url = `${baseUrl}${path}?${new URLSearchParams(params).toString()}`;
     const headers = {};
+    if (this.shouldAddApiKey(apiType) && this.options.apiKey) {
+      headers["x-api-key"] = this.options.apiKey;
+    }
     if (this.shouldAddAffiliate(apiType, baseUrl) && this.options.affiliate) {
       headers["affiliate"] = this.options.affiliate;
     }
     (0, import_sdk_common12.log)(`Fetching ${apiType} API: GET ${url}. Params: ${JSON.stringify(params)}`);
-    const response = await fetch(url, { method: "GET", headers });
-    if (!response.ok) {
-      const errorBody = await response.json();
-      throw new BridgeProviderQuoteError("API_ERROR" /* API_ERROR */, { errorBody, type: errorMessageMap[apiType] });
-    }
-    const json = await response.json();
-    if (isValidResponse && !isValidResponse(json)) {
-      throw new BridgeProviderQuoteError("INVALID_API_JSON_RESPONSE" /* INVALID_API_JSON_RESPONSE */, { json, apiType, params });
+    try {
+      const response = await fetch(url, { method: "GET", headers });
+      if (!response.ok) {
+        if (isInfrastructureError(response.status) && !useFallback) {
+          this.enableFallback(apiType);
+          (0, import_sdk_common12.log)(
+            `Infrastructure error (${response.status}) detected for ${apiType} API. Enabling fallback for ${this.fallbackTimeoutMs}ms`
+          );
+          return this.makeApiCall(apiType, path, params, isValidResponse);
+        }
+        const errorBody = await response.json();
+        throw new BridgeProviderQuoteError("API_ERROR" /* API_ERROR */, { errorBody, type: errorMessageMap[apiType] });
+      }
+      const json = await response.json();
+      if (isValidResponse && !isValidResponse(json)) {
+        throw new BridgeProviderQuoteError("INVALID_API_JSON_RESPONSE" /* INVALID_API_JSON_RESPONSE */, { json, apiType, params });
+      }
+      return json;
+    } catch (error) {
+      if (!useFallback && isClientFetchError(error)) {
+        this.enableFallback(apiType);
+        (0, import_sdk_common12.log)(`Network error detected for ${apiType} API. Enabling fallback for ${this.fallbackTimeoutMs}ms`);
+        return this.makeApiCall(apiType, path, params, isValidResponse);
+      }
+      throw error;
     }
-    return json;
   }
 };
-function isValidQuoteResponse(response) {
-  if (typeof response !== "object" || response === null) {
-    return false;
-  }
-  const resp = response;
-  if (!("success" in resp) || !("statusCode" in resp) || !("result" in resp) || typeof resp.success !== "boolean" || typeof resp.statusCode !== "number") {
-    return false;
-  }
-  const result = resp.result;
-  if (typeof result !== "object" || result === null) {
-    return false;
-  }
-  const res = result;
-  if (!("originChainId" in res) || !("destinationChainId" in res) || !("userAddress" in res) || !("receiverAddress" in res) || !("manualRoutes" in res) || !Array.isArray(res.manualRoutes)) {
-    return false;
-  }
-  return res.manualRoutes.every((route) => {
-    if (typeof route !== "object" || route === null) {
-      return false;
-    }
-    const r = route;
-    if (!("routeDetails" in r) || typeof r.routeDetails !== "object" || r.routeDetails === null) {
-      return false;
-    }
-    if (!("routeFee" in r.routeDetails)) {
-      return false;
-    }
-    const routeFee = r.routeDetails.routeFee;
-    if (typeof routeFee !== "object" || routeFee === null) {
-      return false;
-    }
-    if (!("amount" in routeFee)) {
-      return false;
-    }
-    return "quoteId" in r && "quoteExpiry" in r && "output" in r && "gasFee" in r && "slippage" in r && "estimatedTime" in r && "routeDetails" in r;
-  });
-}
-function isValidBungeeEventsResponse(response) {
-  if (typeof response !== "object" || response === null) {
-    return false;
-  }
-  const resp = response;
-  if (!("success" in resp) || !("result" in resp) || typeof resp.success !== "boolean" || !Array.isArray(resp.result)) {
-    return false;
-  }
-  return resp.result.every((event) => {
-    if (typeof event !== "object" || event === null) {
-      return false;
-    }
-    const e = event;
-    return "identifier" in e && "bridgeName" in e && "fromChainId" in e && "isCowswapTrade" in e && "orderId" in e && // 'recipient' in e &&
-    "sender" in e && "srcTxStatus" in e && "destTxStatus" in e;
-  });
-}
-function isValidAcrossStatusResponse(response) {
-  if (typeof response !== "object" || response === null) {
-    return false;
-  }
-  const resp = response;
-  if (!("status" in resp)) {
-    return false;
-  }
-  return true;
-}
 
 // src/providers/bungee/createBungeeDepositCall.ts
 var import_sdk_config7 = require("@cowprotocol/sdk-config");