@cowprotocol/sdk-bridging 0.4.5 → 0.4.7-rc.0

package/dist/index.mjs

@@ -75,6 +75,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
 import { RAW_FILES_PATH } from "@cowprotocol/sdk-config";
@@ -149,7 +155,7 @@ async function getCrossChainOrder(params) {
 
 // src/BridgingSdk/BridgingSdk.ts
 import { TradingSdk } from "@cowprotocol/sdk-trading";
-import { OrderBookApi } from "@cowprotocol/sdk-order-book";
+import { OrderBookApi as OrderBookApi2 } from "@cowprotocol/sdk-order-book";
 import { ALL_SUPPORTED_CHAINS } from "@cowprotocol/sdk-config";
 import { enableLogging, setGlobalAdapter, TTLCache as TTLCache2 } from "@cowprotocol/sdk-common";
 
@@ -184,14 +190,14 @@ function getQuoteWithoutBridge(params) {
 import {
   getTradeParametersAfterQuote,
   mergeAppDataDoc,
-  postSwapOrderFromQuote
+  postSwapOrderFromQuote as postSwapOrderFromQuoteTrading
 } from "@cowprotocol/sdk-trading";
-import { getGlobalAdapter as getGlobalAdapter2, jsonWithBigintReplacer as jsonWithBigintReplacer2, log as log2 } from "@cowprotocol/sdk-common";
+import { getGlobalAdapter as getGlobalAdapter3, log as log3 } from "@cowprotocol/sdk-common";
 import { OrderKind } from "@cowprotocol/sdk-order-book";
 
 // src/BridgingSdk/getBridgeSignedHook.ts
 import { getGlobalAdapter } from "@cowprotocol/sdk-common";
-async function getBridgeSignedHook(bridgeRequest, { provider, signer, hookGasLimit, swapResult, validToOverride }) {
+async function getBridgeSignedHook(provider, bridgeRequest, { signer, hookGasLimit, swapResult, validToOverride }) {
   const adapter = getGlobalAdapter();
   const bridgingQuote = await provider.getQuote(bridgeRequest);
   const unsignedBridgeCall = await provider.getUnsignedBridgeCall(bridgeRequest, bridgingQuote);
@@ -225,9 +231,14 @@ function getHookMockForCostEstimation(gasLimit) {
   };
 }
 
-// src/BridgingSdk/getQuoteWithBridge.ts
-async function getQuoteWithBridge(params) {
-  const { provider, swapAndBridgeRequest, advancedSettings, tradingSdk, bridgeHookSigner } = params;
+// src/BridgingSdk/getIntermediateSwapResult.ts
+import { getGlobalAdapter as getGlobalAdapter2, jsonWithBigintReplacer as jsonWithBigintReplacer2, log as log2 } from "@cowprotocol/sdk-common";
+async function getIntermediateSwapResult({
+  provider,
+  params,
+  getBridgeHook
+}) {
+  const { swapAndBridgeRequest, advancedSettings, tradingSdk } = params;
   const {
     kind,
     sellTokenChainId,
@@ -235,25 +246,101 @@ async function getQuoteWithBridge(params) {
     buyTokenChainId,
     buyTokenAddress,
     amount,
-    signer: signerLike,
-    ...rest
+    signer: signerLike
   } = swapAndBridgeRequest;
   const adapter = getGlobalAdapter2();
   const signer = signerLike ? adapter.createSigner(signerLike) : adapter.signer;
-  if (kind !== OrderKind.SELL) {
-    throw new Error("Bridging only support SELL orders");
-  }
   log2(
     `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);
-  log2(`Using mocked hook for swap gas estimation: ${JSON.stringify(mockedHook)}`);
+  const intermediateToken = intermediateTokens[0];
+  log2(`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;
+  log2(
+    `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,
@@ -272,52 +359,149 @@ async function getQuoteWithBridge(params) {
       jsonWithBigintReplacer2
     )}`
   );
-  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 !== 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: getTradeParametersAfterQuote({
+          quoteParameters: swapResult.tradeParameters,
+          sellToken: sellTokenAddress
+        }),
+        signer
+      },
+      orderBookApi
+    };
+    await signingStepManager?.beforeOrderSign?.();
+    return postSwapOrderFromQuoteTrading(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
+    });
+    log3(`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);
+      log3(`Using mocked hook for swap gas estimation: ${JSON.stringify(mockedHook)}`);
+      return mockedHook;
     }
   });
-  const intermediateTokenAmount = swapResult.amountsAndCosts.afterSlippage.buyAmount;
-  log2(
-    `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: OrderKind.SELL },
+    } = await getHookBridgeResult(provider, {
+      swapAndBridgeRequest,
       swapResult,
       bridgeRequestWithoutAmount: {
         ...bridgeRequestWithoutAmount,
         receiver: receiverOverride || bridgeRequestWithoutAmount.receiver
       },
-      provider,
       intermediateTokenAmount,
       signer: signer2,
       appDataOverride,
       validToOverride,
       hookGasLimit
     });
-    log2(`Bridge hook for swap: ${JSON.stringify(bridgeHook)}`);
+    log3(`Bridge hook for swap: ${JSON.stringify(bridgeHook)}`);
     swapResult.tradeParameters.receiver = bridgeHook.recipient;
-    log2(`App data for swap: appDataKeccak256=${appDataKeccak256}, fullAppData="${fullAppData}"`);
+    log3(`App data for swap: appDataKeccak256=${appDataKeccak256}, fullAppData="${fullAppData}"`);
     swapResult.appDataInfo = {
       fullAppData,
       appDataKeccak256,
@@ -334,93 +518,58 @@ async function getQuoteWithBridge(params) {
       }
     };
   }
-  log2(`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
+  log3(`Using gas limit: ${hookEstimatedGasLimit}`);
+  const result = await getBridgeProviderQuote(
+    // Sign the hooks with quoteSigner if provided
+    quoteSigner ? getGlobalAdapter3().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: getTradeParametersAfterQuote({
-            quoteParameters: swapResult2.tradeParameters,
-            sellToken: sellTokenAddress
-          }),
-          signer
-        },
-        orderBookApi
-      };
-      await signingStepManager?.beforeOrderSign?.();
-      return 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];
-  log2(`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 mergeAppDataDoc(swapResult.appDataInfo.doc, appDataOverride || {});
   const swapResultHooks = swapAppData.doc.metadata.hooks;
   const postHooks = (swapResultHooks?.post || []).filter((hook) => {
@@ -484,14 +633,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,
@@ -643,15 +791,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 = {
@@ -720,14 +867,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 = {
@@ -784,7 +931,7 @@ var BridgingSdk = class {
       enableLogging(options.enableLogging);
     }
     const tradingSdk = options.tradingSdk ?? new TradingSdk();
-    const orderBookApi = tradingSdk?.options.orderBookApi ?? new OrderBookApi();
+    const orderBookApi = tradingSdk?.options.orderBookApi ?? new OrderBookApi2();
     this.config = {
       ...restOptions,
       providers,
@@ -970,7 +1117,7 @@ var BridgingSdk = class {
 };
 
 // src/providers/across/AcrossApi.ts
-import { log as log3 } from "@cowprotocol/sdk-common";
+import { log as log4 } from "@cowprotocol/sdk-common";
 var ACROSS_API_URL = "https://app.across.to/api";
 var AcrossApi = class {
   constructor(options = {}) {
@@ -1036,7 +1183,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()}`;
-    log3(`Fetching Across API: GET ${url}. Params: ${JSON.stringify(params)}`);
+    log4(`Fetching Across API: GET ${url}. Params: ${JSON.stringify(params)}`);
     const response = await fetch(url, {
       method: "GET"
     });
@@ -1075,14 +1222,14 @@ function isValidRoute(item) {
 }
 
 // src/providers/across/const/interfaces.ts
-import { getGlobalAdapter as getGlobalAdapter3 } from "@cowprotocol/sdk-common";
+import { getGlobalAdapter as getGlobalAdapter4 } from "@cowprotocol/sdk-common";
 var ACROSS_DEPOSIT_EVENT_INTERFACE = () => {
-  return getGlobalAdapter3().utils.createInterface([
+  return getGlobalAdapter4().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 getGlobalAdapter3().utils.createInterface([
+  return getGlobalAdapter4().utils.createInterface([
     "event Trade(address owner, address sellToken, address buyToken, uint256 sellAmount, uint256 buyAmount, uint256 feeAmount, bytes orderUid)"
   ]);
 };
@@ -1130,7 +1277,7 @@ var ACROSS_MATH_CONTRACT_ADDRESSES = {
 // src/providers/across/util.ts
 import { COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS } from "@cowprotocol/sdk-config";
 import { getBigNumber, OrderKind as OrderKind2 } from "@cowprotocol/sdk-order-book";
-import { getGlobalAdapter as getGlobalAdapter4 } from "@cowprotocol/sdk-common";
+import { getGlobalAdapter as getGlobalAdapter5 } from "@cowprotocol/sdk-common";
 var PCT_100_PERCENT = 10n ** 18n;
 function toBridgeQuoteResult(request, slippageBps, suggestedFees) {
   const { kind } = request;
@@ -1187,7 +1334,7 @@ function toAmountsAndCosts(request, slippageBps, suggestedFees) {
   };
 }
 function bytes32ToAddress(address) {
-  return getGlobalAdapter4().utils.decodeAbi(["address"], address).toString();
+  return getGlobalAdapter5().utils.decodeAbi(["address"], address).toString();
 }
 function assertValidPct(pct) {
   if (pct > PCT_100_PERCENT || pct < 0n) {
@@ -1222,8 +1369,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);
@@ -1264,8 +1411,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() === COW_PROTOCOL_SETTLEMENT_CONTRACT_ADDRESS[chainId].toLowerCase() && log6.topics[0] === COW_TRADE_EVENT_TOPIC;
+  const cowTradeEvents = logs.filter((log7) => {
+    return log7.address.toLowerCase() === 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);
@@ -3065,11 +3212,11 @@ var ACROSS_SPOKE_POOL_ABI = [
 ];
 
 // src/providers/across/createAcrossDepositCall.ts
-import { getGlobalAdapter as getGlobalAdapter5 } from "@cowprotocol/sdk-common";
+import { getGlobalAdapter as getGlobalAdapter6 } from "@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 = getGlobalAdapter5();
+  const adapter = getGlobalAdapter6();
   const spokePoolAddress = ACROSS_SPOOK_CONTRACT_ADDRESSES[sellTokenChainId];
   if (!spokePoolAddress) {
     throw new Error("Spoke pool address not found for chain: " + sellTokenChainId);
@@ -3080,7 +3227,7 @@ function getSpookPoolContract(sellTokenChainId) {
   );
 }
 function getMathContract(sellTokenChainId) {
-  const adapter = getGlobalAdapter5();
+  const adapter = getGlobalAdapter6();
   const mathContractAddress = ACROSS_MATH_CONTRACT_ADDRESSES[sellTokenChainId];
   if (!mathContractAddress) {
     throw new Error("Math contract address not found for chain: " + sellTokenChainId);
@@ -3091,14 +3238,14 @@ function getMathContract(sellTokenChainId) {
   );
 }
 function getBalanceOfSellTokenContract(sellTokenAddress) {
-  const adapter = getGlobalAdapter5();
+  const adapter = getGlobalAdapter6();
   return createWeirollContract(
     adapter.getContract(sellTokenAddress, ERC20_BALANCE_OF_ABI),
     WeirollCommandFlags.STATICCALL
   );
 }
 function getApproveSellTokenContract(sellTokenAddress) {
-  const adapter = getGlobalAdapter5();
+  const adapter = getGlobalAdapter6();
   return createWeirollContract(adapter.getContract(sellTokenAddress, ERC20_APPROVE_OF_ABI), WeirollCommandFlags.CALL);
 }
 function createAcrossDepositCall(params) {
@@ -3143,7 +3290,7 @@ function createAcrossDepositCall(params) {
 }
 
 // src/providers/across/getDepositParams.ts
-import { log as log4 } from "@cowprotocol/sdk-common";
+import { log as log5 } from "@cowprotocol/sdk-common";
 async function getDepositParams(chainId, orderId, txReceipt) {
   const depositEvents = getAcrossDepositEvents(chainId, txReceipt.logs);
   if (depositEvents.length === 0) {
@@ -3155,7 +3302,7 @@ async function getDepositParams(chainId, orderId, txReceipt) {
     return null;
   const depositEvent = depositEvents[orderTradeIndex];
   if (!depositEvent) {
-    log4(`Trade event found at index ${orderTradeIndex} but only ${depositEvents.length} deposit events available`);
+    log5(`Trade event found at index ${orderTradeIndex} but only ${depositEvents.length} deposit events available`);
     return null;
   }
   return {
@@ -3174,14 +3321,14 @@ async function getDepositParams(chainId, orderId, txReceipt) {
 }
 
 // src/providers/utils/getGasLimitEstimationForHook.ts
-import { getGlobalAdapter as getGlobalAdapter6 } from "@cowprotocol/sdk-common";
+import { getGlobalAdapter as getGlobalAdapter7 } from "@cowprotocol/sdk-common";
 async function getGasLimitEstimationForHook({
   cowShedSdk,
   request,
   extraGas,
   extraGasProxyCreation
 }) {
-  const adapter = getGlobalAdapter6();
+  const adapter = getGlobalAdapter7();
   const proxyAddress = cowShedSdk.getCowShedAccount(request.sellTokenChainId, request.owner || request.account);
   const proxyCode = await adapter.getCode(proxyAddress);
   if (!proxyCode || proxyCode === "0x") {
@@ -3192,7 +3339,7 @@ async function getGasLimitEstimationForHook({
 }
 
 // src/providers/across/AcrossBridgeProvider.ts
-import { getGlobalAdapter as getGlobalAdapter7, setGlobalAdapter as setGlobalAdapter2 } from "@cowprotocol/sdk-common";
+import { getGlobalAdapter as getGlobalAdapter8, setGlobalAdapter as setGlobalAdapter2 } from "@cowprotocol/sdk-common";
 import {
   arbitrumOne,
   base,
@@ -3206,6 +3353,7 @@ var ACROSS_HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX}/across`;
 var ACROSS_SUPPORTED_NETWORKS = [mainnet, polygon, arbitrumOne, base, optimism];
 var SLIPPAGE_TOLERANCE_BPS = 0;
 var AcrossBridgeProvider = class {
+  type = "HookBridgeProvider";
   api;
   cowShedSdk;
   supportedTokens = null;
@@ -3307,7 +3455,7 @@ var AcrossBridgeProvider = class {
     throw new Error("Not implemented");
   }
   async getBridgingParams(chainId, orderUid, txHash) {
-    const adapter = getGlobalAdapter7();
+    const adapter = getGlobalAdapter8();
     const txReceipt = await adapter.getTransactionReceipt(txHash);
     if (!txReceipt)
       return null;
@@ -3825,7 +3973,7 @@ var BUNGEE_APPROVE_AND_BRIDGE_V1_ABI = [
 ];
 
 // src/providers/bungee/BungeeApi.ts
-import { getGlobalAdapter as getGlobalAdapter8, log as log5 } from "@cowprotocol/sdk-common";
+import { getGlobalAdapter as getGlobalAdapter9, log as log6 } from "@cowprotocol/sdk-common";
 
 // src/providers/bungee/consts.ts
 var BUNGEE_API_PATH = "/api/v1/bungee";
@@ -4099,7 +4247,7 @@ var BungeeApi = class {
    * @returns True if the bungee tx data is valid, false otherwise
    */
   async verifyBungeeBuildTxData(originChainId, txData, routeId, expectedSocketRequest) {
-    const adapter = getGlobalAdapter8();
+    const adapter = getGlobalAdapter9();
     const socketVerifierAddress = SocketVerifierAddresses[originChainId];
     if (!socketVerifierAddress) {
       throw new BridgeProviderQuoteError("TX_BUILD_ERROR" /* TX_BUILD_ERROR */, {
@@ -4220,13 +4368,13 @@ var BungeeApi = class {
     if (this.shouldAddAffiliate(apiType, baseUrl) && this.options.affiliate) {
       headers["affiliate"] = this.options.affiliate;
     }
-    log5(`Fetching ${apiType} API: GET ${url}. Params: ${JSON.stringify(params)}`);
+    log6(`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);
-          log5(
+          log6(
             `Infrastructure error (${response.status}) detected for ${apiType} API. Enabling fallback for ${this.fallbackTimeoutMs}ms`
           );
           return this.makeApiCall(apiType, path, params, isValidResponse);
@@ -4242,7 +4390,7 @@ var BungeeApi = class {
     } catch (error) {
       if (!useFallback && isClientFetchError(error)) {
         this.enableFallback(apiType);
-        log5(`Network error detected for ${apiType} API. Enabling fallback for ${this.fallbackTimeoutMs}ms`);
+        log6(`Network error detected for ${apiType} API. Enabling fallback for ${this.fallbackTimeoutMs}ms`);
         return this.makeApiCall(apiType, path, params, isValidResponse);
       }
       throw error;
@@ -4252,9 +4400,9 @@ var BungeeApi = class {
 
 // src/providers/bungee/createBungeeDepositCall.ts
 import { ETH_ADDRESS } from "@cowprotocol/sdk-config";
-import { getGlobalAdapter as getGlobalAdapter9 } from "@cowprotocol/sdk-common";
+import { getGlobalAdapter as getGlobalAdapter10 } from "@cowprotocol/sdk-common";
 async function createBungeeDepositCall(params) {
-  const adapter = getGlobalAdapter9();
+  const adapter = getGlobalAdapter10();
   const { request, quote } = params;
   const { bungeeQuote, buildTx } = quote;
   const bridge = bungeeQuote.routeBridge;
@@ -4370,6 +4518,7 @@ var BungeeBridgeProvider = class {
     this.api = new BungeeApi(options.apiOptions);
     this.cowShedSdk = new CowShedSdk2(adapter, options.cowShedOptions?.factoryOptions);
   }
+  type = "HookBridgeProvider";
   api;
   cowShedSdk;
   info = {
@@ -4533,5 +4682,7 @@ export {
   getPostHooks,
   isAppDoc,
   isBridgeQuoteAndPost,
-  isQuoteAndPost
+  isHookBridgeProvider,
+  isQuoteAndPost,
+  isReceiverAccountBridgeProvider
 };