@cowprotocol/sdk-bridging 0.4.6 → 0.5.0

package/dist/index.js

@@ -40,7 +40,9 @@ __export(src_exports, {
   getPostHooks: () => getPostHooks,
   isAppDoc: () => isAppDoc,
   isBridgeQuoteAndPost: () => isBridgeQuoteAndPost,
-  isQuoteAndPost: () => isQuoteAndPost
+  isHookBridgeProvider: () => isHookBridgeProvider,
+  isQuoteAndPost: () => isQuoteAndPost,
+  isReceiverAccountBridgeProvider: () => isReceiverAccountBridgeProvider
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -121,6 +123,12 @@ function getPostHooks(fullAppData) {
 function isAppDoc(appData) {
   return typeof appData === "object" && appData !== null && "version" in appData && "metadata" in appData;
 }
+function isHookBridgeProvider(provider) {
+  return provider.type === "HookBridgeProvider";
+}
+function isReceiverAccountBridgeProvider(provider) {
+  return provider.type === "ReceiverAccountBridgeProvider";
+}
 
 // src/const.ts
 var import_sdk_config = require("@cowprotocol/sdk-config");
@@ -197,7 +205,7 @@ async function getCrossChainOrder(params) {
 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 import_sdk_common5 = require("@cowprotocol/sdk-common");
 
 // src/BridgingSdk/helpers.ts
 var getCacheKey = ({
@@ -228,12 +236,12 @@ 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_common4 = 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");
-async function getBridgeSignedHook(bridgeRequest, { provider, signer, hookGasLimit, swapResult, validToOverride }) {
+async function getBridgeSignedHook(provider, bridgeRequest, { signer, hookGasLimit, swapResult, validToOverride }) {
   const adapter = (0, import_sdk_common2.getGlobalAdapter)();
   const bridgingQuote = await provider.getQuote(bridgeRequest);
   const unsignedBridgeCall = await provider.getUnsignedBridgeCall(bridgeRequest, bridgingQuote);
@@ -267,9 +275,14 @@ function getHookMockForCostEstimation(gasLimit) {
   };
 }
 
-// src/BridgingSdk/getQuoteWithBridge.ts
-async function getQuoteWithBridge(params) {
-  const { provider, swapAndBridgeRequest, advancedSettings, tradingSdk, bridgeHookSigner } = params;
+// src/BridgingSdk/getIntermediateSwapResult.ts
+var import_sdk_common3 = require("@cowprotocol/sdk-common");
+async function getIntermediateSwapResult({
+  provider,
+  params,
+  getBridgeHook
+}) {
+  const { swapAndBridgeRequest, advancedSettings, tradingSdk } = params;
   const {
     kind,
     sellTokenChainId,
@@ -277,25 +290,101 @@ async function getQuoteWithBridge(params) {
     buyTokenChainId,
     buyTokenAddress,
     amount,
-    signer: signerLike,
-    ...rest
+    signer: signerLike
   } = swapAndBridgeRequest;
   const adapter = (0, import_sdk_common3.getGlobalAdapter)();
   const signer = signerLike ? adapter.createSigner(signerLike) : adapter.signer;
-  if (kind !== import_sdk_order_book.OrderKind.SELL) {
-    throw new Error("Bridging only support SELL orders");
-  }
   (0, import_sdk_common3.log)(
     `Cross-chain ${kind} ${amount} ${sellTokenAddress} (source chain ${sellTokenChainId}) for ${buyTokenAddress} (target chain ${buyTokenChainId})`
   );
-  const bridgeRequestWithoutAmount = await getBaseBridgeQuoteRequest({
-    swapAndBridgeRequest,
+  const intermediateTokens = await getIntermediateTokens({
     provider,
+    quoteBridgeRequest: swapAndBridgeRequest,
     intermediateTokensCache: params.intermediateTokensCache
   });
-  const hookEstimatedGasLimit = await provider.getGasLimitEstimationForHook(bridgeRequestWithoutAmount);
-  const mockedHook = getHookMockForCostEstimation(hookEstimatedGasLimit);
-  (0, import_sdk_common3.log)(`Using mocked hook for swap gas estimation: ${JSON.stringify(mockedHook)}`);
+  const intermediateToken = intermediateTokens[0];
+  (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 });
+  }
+  const bridgeRequestWithoutAmount = {
+    ...swapAndBridgeRequest,
+    sellTokenAddress: intermediateToken.address,
+    sellTokenDecimals: intermediateToken.decimals
+  };
+  const { sellTokenDecimals: intermediaryTokenDecimals } = bridgeRequestWithoutAmount;
+  const bridgeHook = getBridgeHook ? await getBridgeHook(bridgeRequestWithoutAmount) : void 0;
+  const advancedSettingsHooks = advancedSettings?.appData?.metadata?.hooks;
+  const hooks = bridgeHook ? {
+    pre: advancedSettingsHooks?.pre,
+    post: [...advancedSettingsHooks?.post || [], bridgeHook]
+  } : advancedSettingsHooks;
+  const finalAdvancedSettings = {
+    ...advancedSettings,
+    appData: {
+      ...advancedSettings?.appData,
+      metadata: {
+        hooks,
+        bridging: {
+          destinationChainId: buyTokenChainId.toString(),
+          destinationTokenAddress: buyTokenAddress
+        }
+      }
+    }
+  };
+  const { swapResult, orderBookApi } = await getSwapQuote({
+    swapAndBridgeRequest,
+    bridgeRequestWithoutAmount,
+    tradingSdk,
+    advancedSettings: finalAdvancedSettings,
+    signer
+  });
+  const intermediateTokenAmount = swapResult.amountsAndCosts.afterSlippage.buyAmount;
+  (0, import_sdk_common3.log)(
+    `Expected to receive ${intermediateTokenAmount} of the intermediate token (${(intermediateTokenAmount / 10n ** BigInt(intermediaryTokenDecimals)).toString()} formatted)`
+  );
+  return {
+    swapAndBridgeRequest,
+    signer,
+    bridgeRequestWithoutAmount,
+    intermediateTokenAmount,
+    intermediaryTokenDecimals,
+    swapResult,
+    orderBookApi
+  };
+}
+async function getIntermediateTokens(params) {
+  const { provider, 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 */);
+  }
+  return intermediateTokens;
+}
+async function getSwapQuote(params) {
+  const { swapAndBridgeRequest, bridgeRequestWithoutAmount, tradingSdk, advancedSettings, signer } = params;
+  const {
+    kind,
+    sellTokenChainId,
+    sellTokenAddress,
+    buyTokenChainId: _buyTokenChainId,
+    buyTokenAddress: _buyTokenAddress,
+    amount,
+    ...rest
+  } = swapAndBridgeRequest;
   const { sellTokenAddress: intermediateToken, sellTokenDecimals: intermediaryTokenDecimals } = bridgeRequestWithoutAmount;
   const swapParams = {
     ...rest,
@@ -314,52 +403,149 @@ async function getQuoteWithBridge(params) {
       import_sdk_common3.jsonWithBigintReplacer
     )}`
   );
-  const advancedSettingsHooks = advancedSettings?.appData?.metadata?.hooks;
-  const { result: swapResult, orderBookApi } = await tradingSdk.getQuoteResults(swapParams, {
-    ...advancedSettings,
-    appData: {
-      ...advancedSettings?.appData,
-      metadata: {
-        hooks: {
-          pre: advancedSettingsHooks?.pre,
-          post: [...advancedSettingsHooks?.post || [], mockedHook]
-        },
-        bridging: {
-          destinationChainId: buyTokenChainId.toString(),
-          destinationTokenAddress: buyTokenAddress
+  const { result: swapResult, orderBookApi } = await tradingSdk.getQuoteResults(swapParams, advancedSettings);
+  return { swapResult, orderBookApi };
+}
+
+// src/BridgingSdk/getQuoteWithBridge.ts
+async function getQuoteWithBridge(provider, params) {
+  const { kind } = params.swapAndBridgeRequest;
+  if (kind !== import_sdk_order_book.OrderKind.SELL) {
+    throw new Error("Bridging only support SELL orders");
+  }
+  if (isHookBridgeProvider(provider)) {
+    return getQuoteWithHookBridge(provider, params);
+  }
+  if (isReceiverAccountBridgeProvider(provider)) {
+    return getQuoteWithReceiverAccountBridge(provider, params);
+  }
+  throw new Error("Provider type is unknown: " + provider.type);
+}
+function createPostSwapOrderFromQuote(params) {
+  const { getBridgeProviderQuote, signer, sellTokenAddress, orderBookApi } = params;
+  return async function postSwapOrderFromQuote(advancedSettings, signingStepManager) {
+    await signingStepManager?.beforeBridgingSign?.();
+    const { swapResult } = await getBridgeProviderQuote(signer, advancedSettings).catch((error) => {
+      signingStepManager?.onBridgingSignError?.();
+      throw error;
+    });
+    await signingStepManager?.afterBridgingSign?.();
+    const quoteResults = {
+      result: {
+        ...swapResult,
+        tradeParameters: (0, import_sdk_trading.getTradeParametersAfterQuote)({
+          quoteParameters: swapResult.tradeParameters,
+          sellToken: sellTokenAddress
+        }),
+        signer
+      },
+      orderBookApi
+    };
+    await signingStepManager?.beforeOrderSign?.();
+    return (0, import_sdk_trading.postSwapOrderFromQuote)(quoteResults, {
+      ...advancedSettings,
+      appData: swapResult.appDataInfo.doc,
+      quoteRequest: {
+        ...advancedSettings?.quoteRequest,
+        // Changing receiver back for the quote request
+        receiver: swapResult.tradeParameters.receiver
+      }
+    }).then(async (result) => {
+      await signingStepManager?.afterOrderSign?.();
+      return result;
+    }).catch((error) => {
+      signingStepManager?.onOrderSignError?.();
+      throw error;
+    });
+  };
+}
+async function getQuoteWithReceiverAccountBridge(provider, params) {
+  const {
+    swapAndBridgeRequest,
+    signer,
+    bridgeRequestWithoutAmount,
+    intermediateTokenAmount,
+    swapResult,
+    orderBookApi
+  } = await getIntermediateSwapResult({
+    provider,
+    params
+  });
+  async function getBridgeProviderQuote() {
+    const { bridgeReceiverOverride, bridgeResult } = await getAccountBridgeResult(provider, {
+      swapAndBridgeRequest,
+      bridgeRequestWithoutAmount,
+      intermediateTokenAmount
+    });
+    (0, import_sdk_common4.log)(`Bridge receiver override: ${bridgeReceiverOverride}`);
+    swapResult.tradeParameters.receiver = bridgeReceiverOverride;
+    return {
+      bridgeResult,
+      swapResult: {
+        ...swapResult,
+        tradeParameters: {
+          ...swapResult.tradeParameters,
+          receiver: bridgeReceiverOverride
         }
       }
+    };
+  }
+  const result = await getBridgeProviderQuote();
+  return {
+    swap: result.swapResult,
+    bridge: result.bridgeResult,
+    postSwapOrderFromQuote: createPostSwapOrderFromQuote({
+      getBridgeProviderQuote,
+      signer,
+      sellTokenAddress: swapAndBridgeRequest.sellTokenAddress,
+      orderBookApi
+    })
+  };
+}
+async function getQuoteWithHookBridge(provider, params) {
+  const { quoteSigner } = params;
+  const {
+    signer,
+    swapAndBridgeRequest,
+    bridgeRequestWithoutAmount,
+    intermediateTokenAmount,
+    orderBookApi,
+    swapResult
+  } = await getIntermediateSwapResult({
+    provider,
+    params,
+    getBridgeHook: async (bridgeRequestWithoutAmount2) => {
+      const hookEstimatedGasLimit2 = await provider.getGasLimitEstimationForHook(bridgeRequestWithoutAmount2);
+      const mockedHook = getHookMockForCostEstimation(hookEstimatedGasLimit2);
+      (0, import_sdk_common4.log)(`Using mocked hook for swap gas estimation: ${JSON.stringify(mockedHook)}`);
+      return mockedHook;
     }
   });
-  const intermediateTokenAmount = swapResult.amountsAndCosts.afterSlippage.buyAmount;
-  (0, import_sdk_common3.log)(
-    `Expected to receive ${intermediateTokenAmount} of the intermediate token (${(intermediateTokenAmount / 10n ** BigInt(intermediaryTokenDecimals)).toString()} formatted)`
-  );
-  async function signHooksAndSetSwapResult(signer2, hookGasLimit, advancedSettings2) {
-    const appDataOverride = advancedSettings2?.appData;
-    const receiverOverride = advancedSettings2?.quoteRequest?.receiver;
-    const validToOverride = advancedSettings2?.quoteRequest?.validTo;
+  const hookEstimatedGasLimit = await provider.getGasLimitEstimationForHook(bridgeRequestWithoutAmount);
+  async function getBridgeProviderQuote(signer2, hookGasLimit, advancedSettings) {
+    const appDataOverride = advancedSettings?.appData;
+    const receiverOverride = advancedSettings?.quoteRequest?.receiver;
+    const validToOverride = advancedSettings?.quoteRequest?.validTo;
     const {
       bridgeHook,
       appDataInfo: { doc: appData, fullAppData, appDataKeccak256 },
       bridgeResult
-    } = await getBridgeResult({
-      swapAndBridgeRequest: { ...swapAndBridgeRequest, kind: import_sdk_order_book.OrderKind.SELL },
+    } = await getHookBridgeResult(provider, {
+      swapAndBridgeRequest,
       swapResult,
       bridgeRequestWithoutAmount: {
         ...bridgeRequestWithoutAmount,
         receiver: receiverOverride || bridgeRequestWithoutAmount.receiver
       },
-      provider,
       intermediateTokenAmount,
       signer: signer2,
       appDataOverride,
       validToOverride,
       hookGasLimit
     });
-    (0, import_sdk_common3.log)(`Bridge hook for swap: ${JSON.stringify(bridgeHook)}`);
+    (0, import_sdk_common4.log)(`Bridge hook for swap: ${JSON.stringify(bridgeHook)}`);
     swapResult.tradeParameters.receiver = bridgeHook.recipient;
-    (0, import_sdk_common3.log)(`App data for swap: appDataKeccak256=${appDataKeccak256}, fullAppData="${fullAppData}"`);
+    (0, import_sdk_common4.log)(`App data for swap: appDataKeccak256=${appDataKeccak256}, fullAppData="${fullAppData}"`);
     swapResult.appDataInfo = {
       fullAppData,
       appDataKeccak256,
@@ -376,93 +562,58 @@ async function getQuoteWithBridge(params) {
       }
     };
   }
-  (0, import_sdk_common3.log)(`Using gas limit: ${hookEstimatedGasLimit}`);
-  const result = await signHooksAndSetSwapResult(
-    // Sign the hooks with bridgeHookSigner if provided
-    bridgeHookSigner ? adapter.createSigner(bridgeHookSigner) : signer,
-    // Use estimated hook gas limit if bridgeHookSigner is provided, so we don't have to estimate the hook gas limit twice
-    // Moreover, since bridgeHookSigner is not the real signer, the estimation will fail
+  (0, import_sdk_common4.log)(`Using gas limit: ${hookEstimatedGasLimit}`);
+  const result = await getBridgeProviderQuote(
+    // Sign the hooks with quoteSigner if provided
+    quoteSigner ? (0, import_sdk_common4.getGlobalAdapter)().createSigner(quoteSigner) : signer,
+    // Use estimated hook gas limit if quoteSigner is provided, so we don't have to estimate the hook gas limit twice
+    // Moreover, since quoteSigner is not the real signer, the estimation will fail
     hookEstimatedGasLimit
   );
   return {
     swap: result.swapResult,
     bridge: result.bridgeResult,
-    async postSwapOrderFromQuote(advancedSettings2, signingStepManager) {
-      await signingStepManager?.beforeBridgingSign?.();
-      const { swapResult: swapResult2 } = await signHooksAndSetSwapResult(signer, hookEstimatedGasLimit, advancedSettings2).catch(
-        (error) => {
-          signingStepManager?.onBridgingSignError?.();
-          throw error;
-        }
-      );
-      await signingStepManager?.afterBridgingSign?.();
-      const quoteResults = {
-        result: {
-          ...swapResult2,
-          tradeParameters: (0, import_sdk_trading.getTradeParametersAfterQuote)({
-            quoteParameters: swapResult2.tradeParameters,
-            sellToken: sellTokenAddress
-          }),
-          signer
-        },
-        orderBookApi
-      };
-      await signingStepManager?.beforeOrderSign?.();
-      return (0, import_sdk_trading.postSwapOrderFromQuote)(quoteResults, {
-        ...advancedSettings2,
-        appData: swapResult2.appDataInfo.doc,
-        quoteRequest: {
-          ...advancedSettings2?.quoteRequest,
-          // Changing receiver back to account proxy
-          receiver: swapResult2.tradeParameters.receiver
-        }
-      }).catch((error) => {
-        signingStepManager?.onOrderSignError?.();
-        throw error;
-      }).then(async (result2) => {
-        await signingStepManager?.afterOrderSign?.();
-        return result2;
-      });
-    }
+    postSwapOrderFromQuote: createPostSwapOrderFromQuote({
+      getBridgeProviderQuote: (signer2, advancedSettings) => getBridgeProviderQuote(signer2, hookEstimatedGasLimit, advancedSettings),
+      signer,
+      sellTokenAddress: swapAndBridgeRequest.sellTokenAddress,
+      orderBookApi
+    })
   };
 }
-async function getBaseBridgeQuoteRequest(params) {
-  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?.name ?? intermediateToken?.address} as intermediate tokens`);
-  if (!intermediateToken) {
-    throw new BridgeProviderQuoteError("NO_INTERMEDIATE_TOKENS" /* NO_INTERMEDIATE_TOKENS */, { intermediateTokens });
-  }
-  return {
-    ...quoteBridgeRequest,
-    sellTokenAddress: intermediateToken.address,
-    sellTokenDecimals: intermediateToken.decimals
+async function getAccountBridgeResult(provider, context) {
+  const { bridgeRequestWithoutAmount, intermediateTokenAmount } = context;
+  const bridgeRequest = {
+    ...bridgeRequestWithoutAmount,
+    amount: intermediateTokenAmount
   };
+  const bridgingQuote = await provider.getQuote(bridgeRequest);
+  const bridgeReceiverOverride = await provider.getBridgeReceiverOverride(bridgeRequest, bridgingQuote);
+  const bridgeResult = {
+    providerInfo: provider.info,
+    tradeParameters: bridgeRequest,
+    // Just the bridge (not the swap & bridge)
+    bridgeReceiverOverride,
+    isSell: bridgingQuote.isSell,
+    expectedFillTimeSeconds: bridgingQuote.expectedFillTimeSeconds,
+    fees: bridgingQuote.fees,
+    limits: bridgingQuote.limits,
+    quoteTimestamp: bridgingQuote.quoteTimestamp,
+    amountsAndCosts: bridgingQuote.amountsAndCosts
+  };
+  return { bridgeResult, bridgeReceiverOverride };
 }
-async function getBridgeResult(context) {
-  const { swapResult, bridgeRequestWithoutAmount, provider, intermediateTokenAmount, appDataOverride } = context;
+async function getHookBridgeResult(provider, context) {
+  const { swapResult, bridgeRequestWithoutAmount, intermediateTokenAmount, appDataOverride } = context;
   const bridgeRequest = {
     ...bridgeRequestWithoutAmount,
     amount: intermediateTokenAmount
   };
-  const { hook: bridgeHook, unsignedBridgeCall, bridgingQuote } = await getBridgeSignedHook(bridgeRequest, context);
+  const {
+    hook: bridgeHook,
+    unsignedBridgeCall,
+    bridgingQuote
+  } = await getBridgeSignedHook(provider, bridgeRequest, context);
   const swapAppData = await (0, import_sdk_trading.mergeAppDataDoc)(swapResult.appDataInfo.doc, appDataOverride || {});
   const swapResultHooks = swapAppData.doc.metadata.hooks;
   const postHooks = (swapResultHooks?.post || []).filter((hook) => {
@@ -526,14 +677,13 @@ var SingleQuoteStrategy = class extends BaseSingleQuoteStrategy {
         swapAndBridgeRequest: quoteBridgeRequest,
         advancedSettings,
         tradingSdk,
-        provider,
-        bridgeHookSigner: advancedSettings?.quoteSigner
+        quoteSigner: advancedSettings?.quoteSigner
       };
       const request2 = this.intermediateTokensCache ? {
         ...baseParams,
         intermediateTokensCache: this.intermediateTokensCache
       } : baseParams;
-      return getQuoteWithBridge(request2);
+      return getQuoteWithBridge(provider, request2);
     } else {
       return getQuoteWithoutBridge({
         quoteBridgeRequest,
@@ -685,15 +835,14 @@ var MultiQuoteStrategy = class extends BaseMultiQuoteStrategy {
           swapAndBridgeRequest: quoteBridgeRequest,
           advancedSettings,
           tradingSdk: config.tradingSdk,
-          provider,
-          bridgeHookSigner: advancedSettings?.quoteSigner
+          quoteSigner: advancedSettings?.quoteSigner
         };
         const request = this.intermediateTokensCache ? {
           ...baseParams,
           intermediateTokensCache: this.intermediateTokensCache
         } : baseParams;
         const quote = await Promise.race([
-          getQuoteWithBridge(request),
+          getQuoteWithBridge(provider, request),
           createBridgeQuoteTimeoutPromise(providerTimeout, `Provider ${provider.info.dappId}`)
         ]);
         const result = {
@@ -762,14 +911,14 @@ var BestQuoteStrategy = class extends BaseBestQuoteStrategy {
           advancedSettings,
           tradingSdk: config.tradingSdk,
           provider,
-          bridgeHookSigner: advancedSettings?.quoteSigner
+          quoteSigner: advancedSettings?.quoteSigner
         };
         const request = this.intermediateTokensCache ? {
           ...baseParams,
           intermediateTokensCache: this.intermediateTokensCache
         } : baseParams;
         const quote = await Promise.race([
-          getQuoteWithBridge(request),
+          getQuoteWithBridge(provider, request),
           createBridgeQuoteTimeoutPromise(providerTimeout, `Provider ${provider.info.dappId}`)
         ]);
         const result = {
@@ -816,14 +965,14 @@ var BridgingSdk = class {
   constructor(options, adapter) {
     this.options = options;
     if (adapter) {
-      (0, import_sdk_common4.setGlobalAdapter)(adapter);
+      (0, import_sdk_common5.setGlobalAdapter)(adapter);
     }
     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);
+      (0, import_sdk_common5.enableLogging)(options.enableLogging);
     }
     const tradingSdk = options.tradingSdk ?? new import_sdk_trading2.TradingSdk();
     const orderBookApi = tradingSdk?.options.orderBookApi ?? new import_sdk_order_book2.OrderBookApi();
@@ -834,12 +983,12 @@ var BridgingSdk = class {
       orderBookApi
     };
     this.cacheConfig = { ...DEFAULT_CACHE_CONFIG, ...cacheConfig };
-    this.intermediateTokensCache = new import_sdk_common4.TTLCache(
+    this.intermediateTokensCache = new import_sdk_common5.TTLCache(
       "bridging-intermediate-tokens",
       this.cacheConfig.enabled,
       this.cacheConfig.intermediateTokensTtl
     );
-    this.buyTokensCache = new import_sdk_common4.TTLCache(
+    this.buyTokensCache = new import_sdk_common5.TTLCache(
       "bridging-buy-tokens",
       this.cacheConfig.enabled,
       this.cacheConfig.buyTokensTtl
@@ -1012,7 +1161,7 @@ var BridgingSdk = class {
 };
 
 // src/providers/across/AcrossApi.ts
-var import_sdk_common5 = require("@cowprotocol/sdk-common");
+var import_sdk_common6 = require("@cowprotocol/sdk-common");
 var ACROSS_API_URL = "https://app.across.to/api";
 var AcrossApi = class {
   constructor(options = {}) {
@@ -1078,7 +1227,7 @@ var AcrossApi = class {
   async fetchApi(path, params, isValidResponse) {
     const baseUrl = this.options.apiBaseUrl || ACROSS_API_URL;
     const url = `${baseUrl}${path}?${new URLSearchParams(params).toString()}`;
-    (0, import_sdk_common5.log)(`Fetching Across API: GET ${url}. Params: ${JSON.stringify(params)}`);
+    (0, import_sdk_common6.log)(`Fetching Across API: GET ${url}. Params: ${JSON.stringify(params)}`);
     const response = await fetch(url, {
       method: "GET"
     });
@@ -1117,14 +1266,14 @@ function isValidRoute(item) {
 }
 
 // src/providers/across/const/interfaces.ts
-var import_sdk_common6 = require("@cowprotocol/sdk-common");
+var import_sdk_common7 = require("@cowprotocol/sdk-common");
 var ACROSS_DEPOSIT_EVENT_INTERFACE = () => {
-  return (0, import_sdk_common6.getGlobalAdapter)().utils.createInterface([
+  return (0, import_sdk_common7.getGlobalAdapter)().utils.createInterface([
     "event FundsDeposited(bytes32 inputToken, bytes32 outputToken, uint256 inputAmount, uint256 outputAmount, uint256 indexed destinationChainId, uint256 indexed depositId, uint32 quoteTimestamp, uint32 fillDeadline, uint32 exclusivityDeadline, bytes32 indexed depositor, bytes32 recipient, bytes32 exclusiveRelayer, bytes message)"
   ]);
 };
 var COW_TRADE_EVENT_INTERFACE = () => {
-  return (0, import_sdk_common6.getGlobalAdapter)().utils.createInterface([
+  return (0, import_sdk_common7.getGlobalAdapter)().utils.createInterface([
     "event Trade(address owner, address sellToken, address buyToken, uint256 sellAmount, uint256 buyAmount, uint256 feeAmount, bytes orderUid)"
   ]);
 };
@@ -1172,7 +1321,7 @@ var ACROSS_MATH_CONTRACT_ADDRESSES = {
 // src/providers/across/util.ts
 var import_sdk_config4 = require("@cowprotocol/sdk-config");
 var import_sdk_order_book3 = require("@cowprotocol/sdk-order-book");
-var import_sdk_common7 = require("@cowprotocol/sdk-common");
+var import_sdk_common8 = require("@cowprotocol/sdk-common");
 var PCT_100_PERCENT = 10n ** 18n;
 function toBridgeQuoteResult(request, slippageBps, suggestedFees) {
   const { kind } = request;
@@ -1229,7 +1378,7 @@ function toAmountsAndCosts(request, slippageBps, suggestedFees) {
   };
 }
 function bytes32ToAddress(address) {
-  return (0, import_sdk_common7.getGlobalAdapter)().utils.decodeAbi(["address"], address).toString();
+  return (0, import_sdk_common8.getGlobalAdapter)().utils.decodeAbi(["address"], address).toString();
 }
 function assertValidPct(pct) {
   if (pct > PCT_100_PERCENT || pct < 0n) {
@@ -1264,8 +1413,8 @@ function getAcrossDepositEvents(chainId, logs) {
   }
   const acrossDepositInterface = ACROSS_DEPOSIT_EVENT_INTERFACE();
   const ACROSS_DEPOSIT_EVENT_TOPIC = acrossDepositInterface.getEventTopic("FundsDeposited");
-  const depositEvents = logs.filter((log6) => {
-    return log6.address.toLocaleLowerCase() === spookContractAddress && log6.topics[0] === ACROSS_DEPOSIT_EVENT_TOPIC;
+  const depositEvents = logs.filter((log7) => {
+    return log7.address.toLocaleLowerCase() === spookContractAddress && log7.topics[0] === ACROSS_DEPOSIT_EVENT_TOPIC;
   });
   return depositEvents.map((event) => {
     const parsedLog = acrossDepositInterface.parseLog(event);
@@ -1306,8 +1455,8 @@ function getAcrossDepositEvents(chainId, logs) {
 }
 function getCowTradeEvents(chainId, logs) {
   const COW_TRADE_EVENT_TOPIC = COW_TRADE_EVENT_INTERFACE().getEventTopic("Trade");
-  const cowTradeEvents = logs.filter((log6) => {
-    return log6.address.toLowerCase() === import_sdk_config4.COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId].toLowerCase() && log6.topics[0] === COW_TRADE_EVENT_TOPIC;
+  const cowTradeEvents = logs.filter((log7) => {
+    return log7.address.toLowerCase() === import_sdk_config4.COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId].toLowerCase() && log7.topics[0] === COW_TRADE_EVENT_TOPIC;
   });
   return cowTradeEvents.map((event) => {
     const parsedLog = COW_TRADE_EVENT_INTERFACE().parseLog(event);
@@ -3107,11 +3256,11 @@ var ACROSS_SPOKE_POOL_ABI = [
 ];
 
 // src/providers/across/createAcrossDepositCall.ts
-var import_sdk_common8 = require("@cowprotocol/sdk-common");
+var import_sdk_common9 = require("@cowprotocol/sdk-common");
 var ERC20_BALANCE_OF_ABI = ["function balanceOf(address account) external view returns (uint256)"];
 var ERC20_APPROVE_OF_ABI = ["function approve(address spender, uint256 amount) external returns (bool)"];
 function getSpookPoolContract(sellTokenChainId) {
-  const adapter = (0, import_sdk_common8.getGlobalAdapter)();
+  const adapter = (0, import_sdk_common9.getGlobalAdapter)();
   const spokePoolAddress = ACROSS_SPOOK_CONTRACT_ADDRESSES[sellTokenChainId];
   if (!spokePoolAddress) {
     throw new Error("Spoke pool address not found for chain: " + sellTokenChainId);
@@ -3122,7 +3271,7 @@ function getSpookPoolContract(sellTokenChainId) {
   );
 }
 function getMathContract(sellTokenChainId) {
-  const adapter = (0, import_sdk_common8.getGlobalAdapter)();
+  const adapter = (0, import_sdk_common9.getGlobalAdapter)();
   const mathContractAddress = ACROSS_MATH_CONTRACT_ADDRESSES[sellTokenChainId];
   if (!mathContractAddress) {
     throw new Error("Math contract address not found for chain: " + sellTokenChainId);
@@ -3133,14 +3282,14 @@ function getMathContract(sellTokenChainId) {
   );
 }
 function getBalanceOfSellTokenContract(sellTokenAddress) {
-  const adapter = (0, import_sdk_common8.getGlobalAdapter)();
+  const adapter = (0, import_sdk_common9.getGlobalAdapter)();
   return (0, import_sdk_weiroll.createWeirollContract)(
     adapter.getContract(sellTokenAddress, ERC20_BALANCE_OF_ABI),
     import_sdk_weiroll.WeirollCommandFlags.STATICCALL
   );
 }
 function getApproveSellTokenContract(sellTokenAddress) {
-  const adapter = (0, import_sdk_common8.getGlobalAdapter)();
+  const adapter = (0, import_sdk_common9.getGlobalAdapter)();
   return (0, import_sdk_weiroll.createWeirollContract)(adapter.getContract(sellTokenAddress, ERC20_APPROVE_OF_ABI), import_sdk_weiroll.WeirollCommandFlags.CALL);
 }
 function createAcrossDepositCall(params) {
@@ -3185,7 +3334,7 @@ function createAcrossDepositCall(params) {
 }
 
 // src/providers/across/getDepositParams.ts
-var import_sdk_common9 = require("@cowprotocol/sdk-common");
+var import_sdk_common10 = require("@cowprotocol/sdk-common");
 async function getDepositParams(chainId, orderId, txReceipt) {
   const depositEvents = getAcrossDepositEvents(chainId, txReceipt.logs);
   if (depositEvents.length === 0) {
@@ -3197,7 +3346,7 @@ async function getDepositParams(chainId, orderId, txReceipt) {
     return null;
   const depositEvent = depositEvents[orderTradeIndex];
   if (!depositEvent) {
-    (0, import_sdk_common9.log)(`Trade event found at index ${orderTradeIndex} but only ${depositEvents.length} deposit events available`);
+    (0, import_sdk_common10.log)(`Trade event found at index ${orderTradeIndex} but only ${depositEvents.length} deposit events available`);
     return null;
   }
   return {
@@ -3216,14 +3365,14 @@ async function getDepositParams(chainId, orderId, txReceipt) {
 }
 
 // src/providers/utils/getGasLimitEstimationForHook.ts
-var import_sdk_common10 = require("@cowprotocol/sdk-common");
+var import_sdk_common11 = require("@cowprotocol/sdk-common");
 async function getGasLimitEstimationForHook({
   cowShedSdk,
   request,
   extraGas,
   extraGasProxyCreation
 }) {
-  const adapter = (0, import_sdk_common10.getGlobalAdapter)();
+  const adapter = (0, import_sdk_common11.getGlobalAdapter)();
   const proxyAddress = cowShedSdk.getCowShedAccount(request.sellTokenChainId, request.owner || request.account);
   const proxyCode = await adapter.getCode(proxyAddress);
   if (!proxyCode || proxyCode === "0x") {
@@ -3234,7 +3383,7 @@ async function getGasLimitEstimationForHook({
 }
 
 // src/providers/across/AcrossBridgeProvider.ts
-var import_sdk_common11 = require("@cowprotocol/sdk-common");
+var import_sdk_common12 = require("@cowprotocol/sdk-common");
 var import_sdk_config5 = require("@cowprotocol/sdk-config");
 var import_sdk_cow_shed = require("@cowprotocol/sdk-cow-shed");
 var import_sdk_order_book4 = require("@cowprotocol/sdk-order-book");
@@ -3242,13 +3391,14 @@ var ACROSS_HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX}/across`;
 var ACROSS_SUPPORTED_NETWORKS = [import_sdk_config5.mainnet, import_sdk_config5.polygon, import_sdk_config5.arbitrumOne, import_sdk_config5.base, import_sdk_config5.optimism];
 var SLIPPAGE_TOLERANCE_BPS = 0;
 var AcrossBridgeProvider = class {
+  type = "HookBridgeProvider";
   api;
   cowShedSdk;
   supportedTokens = null;
   constructor(options = {}, _adapter) {
     const adapter = _adapter || options.cowShedOptions?.adapter;
     if (adapter) {
-      (0, import_sdk_common11.setGlobalAdapter)(adapter);
+      (0, import_sdk_common12.setGlobalAdapter)(adapter);
     }
     this.api = new AcrossApi(options.apiOptions);
     this.cowShedSdk = new import_sdk_cow_shed.CowShedSdk(adapter, options.cowShedOptions?.factoryOptions);
@@ -3343,7 +3493,7 @@ var AcrossBridgeProvider = class {
     throw new Error("Not implemented");
   }
   async getBridgingParams(chainId, orderUid, txHash) {
-    const adapter = (0, import_sdk_common11.getGlobalAdapter)();
+    const adapter = (0, import_sdk_common12.getGlobalAdapter)();
     const txReceipt = await adapter.getTransactionReceipt(txHash);
     if (!txReceipt)
       return null;
@@ -3861,7 +4011,7 @@ var BUNGEE_APPROVE_AND_BRIDGE_V1_ABI = [
 ];
 
 // src/providers/bungee/BungeeApi.ts
-var import_sdk_common12 = require("@cowprotocol/sdk-common");
+var import_sdk_common13 = require("@cowprotocol/sdk-common");
 
 // src/providers/bungee/consts.ts
 var BUNGEE_API_PATH = "/api/v1/bungee";
@@ -4135,7 +4285,7 @@ var BungeeApi = class {
    * @returns True if the bungee tx data is valid, false otherwise
    */
   async verifyBungeeBuildTxData(originChainId, txData, routeId, expectedSocketRequest) {
-    const adapter = (0, import_sdk_common12.getGlobalAdapter)();
+    const adapter = (0, import_sdk_common13.getGlobalAdapter)();
     const socketVerifierAddress = SocketVerifierAddresses[originChainId];
     if (!socketVerifierAddress) {
       throw new BridgeProviderQuoteError("TX_BUILD_ERROR" /* TX_BUILD_ERROR */, {
@@ -4256,13 +4406,13 @@ var BungeeApi = class {
     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)}`);
+    (0, import_sdk_common13.log)(`Fetching ${apiType} API: GET ${url}. Params: ${JSON.stringify(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)(
+          (0, import_sdk_common13.log)(
             `Infrastructure error (${response.status}) detected for ${apiType} API. Enabling fallback for ${this.fallbackTimeoutMs}ms`
           );
           return this.makeApiCall(apiType, path, params, isValidResponse);
@@ -4278,7 +4428,7 @@ var BungeeApi = class {
     } 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`);
+        (0, import_sdk_common13.log)(`Network error detected for ${apiType} API. Enabling fallback for ${this.fallbackTimeoutMs}ms`);
         return this.makeApiCall(apiType, path, params, isValidResponse);
       }
       throw error;
@@ -4288,9 +4438,9 @@ var BungeeApi = class {
 
 // src/providers/bungee/createBungeeDepositCall.ts
 var import_sdk_config7 = require("@cowprotocol/sdk-config");
-var import_sdk_common13 = require("@cowprotocol/sdk-common");
+var import_sdk_common14 = require("@cowprotocol/sdk-common");
 async function createBungeeDepositCall(params) {
-  const adapter = (0, import_sdk_common13.getGlobalAdapter)();
+  const adapter = (0, import_sdk_common14.getGlobalAdapter)();
   const { request, quote } = params;
   const { bungeeQuote, buildTx } = quote;
   const bridge = bungeeQuote.routeBridge;
@@ -4383,7 +4533,7 @@ async function getBridgingStatusFromEvents(events, getAcrossStatus) {
 // src/providers/bungee/BungeeBridgeProvider.ts
 var import_sdk_config8 = require("@cowprotocol/sdk-config");
 var import_sdk_cow_shed2 = require("@cowprotocol/sdk-cow-shed");
-var import_sdk_common14 = require("@cowprotocol/sdk-common");
+var import_sdk_common15 = require("@cowprotocol/sdk-common");
 var BUNGEE_HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX2}/bungee`;
 var BUNGEE_SUPPORTED_NETWORKS = [import_sdk_config8.mainnet, import_sdk_config8.polygon, import_sdk_config8.arbitrumOne, import_sdk_config8.base, import_sdk_config8.optimism, import_sdk_config8.avalanche, import_sdk_config8.gnosisChain];
 var SLIPPAGE_TOLERANCE_BPS2 = 0;
@@ -4392,11 +4542,12 @@ var BungeeBridgeProvider = class {
     this.options = options;
     const adapter = _adapter || options.cowShedOptions?.adapter;
     if (adapter) {
-      (0, import_sdk_common14.setGlobalAdapter)(adapter);
+      (0, import_sdk_common15.setGlobalAdapter)(adapter);
     }
     this.api = new BungeeApi(options.apiOptions);
     this.cowShedSdk = new import_sdk_cow_shed2.CowShedSdk(adapter, options.cowShedOptions?.factoryOptions);
   }
+  type = "HookBridgeProvider";
   api;
   cowShedSdk;
   info = {
@@ -4561,5 +4712,7 @@ var BungeeBridgeProvider = class {
   getPostHooks,
   isAppDoc,
   isBridgeQuoteAndPost,
-  isQuoteAndPost
+  isHookBridgeProvider,
+  isQuoteAndPost,
+  isReceiverAccountBridgeProvider
 });