@cowprotocol/sdk-bridging 0.3.2-beta.0 → 0.3.2

package/dist/index.mjs

@@ -76,6 +76,83 @@ function isAppDoc(appData) {
   return typeof appData === "object" && appData !== null && "version" in appData && "metadata" in appData;
 }
 
+// src/const.ts
+import { RAW_FILES_PATH } from "@cowprotocol/sdk-config";
+var RAW_PROVIDERS_FILES_PATH = `${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
+import { TradingSdk } from "@cowprotocol/sdk-trading";
+import { OrderBookApi } from "@cowprotocol/sdk-order-book";
+import { ALL_SUPPORTED_CHAINS } from "@cowprotocol/sdk-config";
+import { enableLogging, setGlobalAdapter } from "@cowprotocol/sdk-common";
+
 // src/BridgingSdk/getQuoteWithoutBridge.ts
 import { jsonWithBigintReplacer, log } from "@cowprotocol/sdk-common";
 function getQuoteWithoutBridge(params) {
@@ -126,15 +203,6 @@ async function getBridgeSignedHook(bridgeRequest, { provider, signer, hookGasLim
   };
 }
 
-// src/const.ts
-import { RAW_FILES_PATH } from "@cowprotocol/sdk-config";
-var RAW_PROVIDERS_FILES_PATH = `${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
 import { OrderKind } from "@cowprotocol/sdk-order-book";
 import { getGlobalAdapter as getGlobalAdapter2, jsonWithBigintReplacer as jsonWithBigintReplacer2, log as log2 } from "@cowprotocol/sdk-common";
@@ -362,73 +430,274 @@ 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/SingleQuoteStrategy.ts
+var SingleQuoteStrategyImpl = class {
+  strategyName = "SingleQuoteStrategy";
+  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");
+      }
+      return getQuoteWithBridge({
+        swapAndBridgeRequest: quoteBridgeRequest,
+        advancedSettings,
+        tradingSdk,
+        provider,
+        bridgeHookSigner: advancedSettings?.quoteSigner
+      });
+    } else {
+      return getQuoteWithoutBridge({
+        quoteBridgeRequest,
+        advancedSettings,
+        tradingSdk
+      });
+    }
   }
-  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`
+// 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 MultiQuoteStrategyImpl = class {
+  strategyName = "MultiQuoteStrategy";
+  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 quote = await Promise.race([
+          getQuoteWithBridge({
+            swapAndBridgeRequest: quoteBridgeRequest,
+            advancedSettings,
+            tradingSdk: config.tradingSdk,
+            provider,
+            bridgeHookSigner: advancedSettings?.quoteSigner
+          }),
+          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 BestQuoteStrategyImpl = class {
+  strategyName = "BestQuoteStrategy";
+  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 quote = await Promise.race([
+          getQuoteWithBridge({
+            swapAndBridgeRequest: quoteBridgeRequest,
+            advancedSettings,
+            tradingSdk: config.tradingSdk,
+            provider,
+            bridgeHookSigner: advancedSettings?.quoteSigner
+          }),
+          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/BridgingSdk.ts
-import { TradingSdk } from "@cowprotocol/sdk-trading";
-import { OrderBookApi } from "@cowprotocol/sdk-order-book";
-import { ALL_SUPPORTED_CHAINS } from "@cowprotocol/sdk-config";
-import { enableLogging, setGlobalAdapter } from "@cowprotocol/sdk-common";
+var singleQuoteStrategy = new SingleQuoteStrategyImpl();
+var multiQuoteStrategy = new MultiQuoteStrategyImpl();
+var bestQuoteStrategy = new BestQuoteStrategyImpl();
 var BridgingSdk = class {
   constructor(options, adapter) {
     this.options = options;
@@ -436,8 +705,8 @@ var BridgingSdk = class {
       setGlobalAdapter(adapter);
     }
     const { providers, ...restOptions } = options;
-    if (!providers || providers.length !== 1) {
-      throw new Error("Current implementation only supports a single bridge provider");
+    if (!providers || providers.length === 0) {
+      throw new Error("At least one bridge provider is required");
     }
     if (options.enableLogging !== void 0) {
       enableLogging(options.enableLogging);
@@ -501,23 +770,47 @@ 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({
-        quoteBridgeRequest,
-        advancedSettings,
-        tradingSdk
-      });
-    }
+    const request = {
+      quoteBridgeRequest,
+      advancedSettings
+    };
+    return singleQuoteStrategy.execute(request, 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 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 bestQuoteStrategy.execute(request, this.config);
   }
   async getOrder(params) {
     const { orderBookApi } = this.config;
@@ -536,6 +829,9 @@ var BridgingSdk = class {
   getProviderFromAppData(fullAppData) {
     return findBridgeProviderFromHook(fullAppData, this.getProviders());
   }
+  getProviderByDappId(dappId) {
+    return this.config.providers.find((provider) => provider.info.dappId === dappId);
+  }
 };
 
 // src/providers/across/AcrossApi.ts
@@ -3395,9 +3691,13 @@ var BUNGEE_APPROVE_AND_BRIDGE_V1_ABI = [
 
 // src/providers/bungee/BungeeApi.ts
 import { getGlobalAdapter as getGlobalAdapter8, log as log5 } from "@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"];
@@ -3407,16 +3707,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))) {
@@ -3644,100 +4026,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;
     }
     log5(`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);
+          log5(
+            `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);
+        log5(`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
 import { ETH_ADDRESS } from "@cowprotocol/sdk-config";