@cowprotocol/sdk-bridging 0.1.0-monorepo.0

package/dist/index.mjs

@@ -0,0 +1,2924 @@
+// src/types.ts
+var BridgeStatus = /* @__PURE__ */ ((BridgeStatus2) => {
+  BridgeStatus2["NOT_INITIATED"] = "not_initiated";
+  BridgeStatus2["IN_PROGRESS"] = "in_progress";
+  BridgeStatus2["EXECUTED"] = "executed";
+  BridgeStatus2["FAILED"] = "failed";
+  BridgeStatus2["EXPIRED"] = "expired";
+  return BridgeStatus2;
+})(BridgeStatus || {});
+
+// src/errors.ts
+var BridgeProviderQuoteError = class extends Error {
+  constructor(message, context) {
+    super(message);
+    this.context = context;
+    this.name = "BridgeProviderQuoteError";
+  }
+};
+
+// src/utils.ts
+function isBridgeQuoteAndPost(quote) {
+  return "bridge" in quote;
+}
+function isQuoteAndPost(quote) {
+  return !isBridgeQuoteAndPost(quote);
+}
+function assertIsBridgeQuoteAndPost(quote) {
+  if (!isBridgeQuoteAndPost(quote)) {
+    throw new Error("Quote result is not of type BridgeQuoteAndPost. Are you sure the sell and buy chains different?");
+  }
+}
+function assertIsQuoteAndPost(quote) {
+  if (!isQuoteAndPost(quote)) {
+    throw new Error("Quote result is not of type QuoteAndPost. Are you sure the sell and buy chains are the same?");
+  }
+}
+function getPostHooks(fullAppData) {
+  if (!fullAppData) {
+    return [];
+  }
+  const appData = JSON.parse(fullAppData);
+  if (!isAppDoc(appData)) {
+    return [];
+  }
+  if (!appData.metadata.hooks) {
+    return [];
+  }
+  return appData.metadata.hooks.post || [];
+}
+function isAppDoc(appData) {
+  return typeof appData === "object" && appData !== null && "version" in appData && "metadata" in appData;
+}
+
+// src/hooks/utils.ts
+function getHookMockForCostEstimation(gasLimit) {
+  return {
+    callData: "0x00",
+    gasLimit: gasLimit.toString(),
+    target: "0x0000000000000000000000000000000000000000"
+  };
+}
+function areHooksEqual(hookA, hookB) {
+  return hookA.callData === hookB.callData && hookA.gasLimit === hookB.gasLimit && hookA.target === hookB.target;
+}
+
+// src/BridgingSdk/BridgingSdk.ts
+import { TradingSdk as TradingSdk2 } from "@cowprotocol/sdk-trading";
+import {
+  ALL_SUPPORTED_CHAINS
+} from "@cowprotocol/sdk-config";
+
+// src/BridgingSdk/getQuoteWithoutBridge.ts
+import { jsonWithBigintReplacer } from "@cowprotocol/sdk-common";
+import { log } from "@cowprotocol/sdk-common";
+function getQuoteWithoutBridge(params) {
+  const { quoteBridgeRequest, advancedSettings, tradingSdk } = params;
+  const { sellTokenAddress, buyTokenAddress, amount, ...rest } = quoteBridgeRequest;
+  const swapParams = {
+    ...rest,
+    chainId: quoteBridgeRequest.sellTokenChainId,
+    sellToken: sellTokenAddress,
+    buyToken: buyTokenAddress,
+    amount: amount.toString()
+  };
+  const { signer: _, ...paramsToLog } = swapParams;
+  log(`Single-chain swap: Delegate to trading SDK with params ${JSON.stringify(paramsToLog, jsonWithBigintReplacer)}`);
+  return tradingSdk.getQuote(swapParams, advancedSettings);
+}
+
+// src/BridgingSdk/getQuoteWithBridge.ts
+import {
+  mergeAppDataDoc,
+  postSwapOrderFromQuote
+} from "@cowprotocol/sdk-trading";
+import { log as log2, jsonWithBigintReplacer as jsonWithBigintReplacer2, getGlobalAdapter } from "@cowprotocol/sdk-common";
+import { OrderKind } from "@cowprotocol/sdk-order-book";
+import { getTradeParametersAfterQuote } from "@cowprotocol/sdk-trading";
+async function getQuoteWithBridge(params) {
+  const { provider, swapAndBridgeRequest, advancedSettings, getErc20Decimals, tradingSdk, bridgeHookSigner } = params;
+  const {
+    kind,
+    sellTokenChainId,
+    sellTokenAddress,
+    buyTokenChainId,
+    buyTokenAddress,
+    amount,
+    signer: signerLike,
+    ...rest
+  } = swapAndBridgeRequest;
+  const adapter = getGlobalAdapter();
+  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,
+    provider,
+    getErc20Decimals
+  });
+  const hookEstimatedGasLimit = provider.getGasLimitEstimationForHook(bridgeRequestWithoutAmount);
+  const mockedHook = getHookMockForCostEstimation(hookEstimatedGasLimit);
+  log2(`Using mocked hook for swap gas estimation: ${JSON.stringify(mockedHook)}`);
+  const { sellTokenAddress: intermediateToken, sellTokenDecimals: intermediaryTokenDecimals } = bridgeRequestWithoutAmount;
+  const swapParams = {
+    ...rest,
+    kind,
+    chainId: sellTokenChainId,
+    sellToken: sellTokenAddress,
+    buyToken: intermediateToken,
+    buyTokenDecimals: intermediaryTokenDecimals,
+    amount: amount.toString(),
+    signer
+  };
+  const { signer: _, ...swapParamsToLog } = swapParams;
+  log2(
+    `Getting a quote for the swap (sell token to buy intermediate token). Delegate to trading SDK with params: ${JSON.stringify(
+      swapParamsToLog,
+      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]
+        }
+      }
+    }
+  });
+  const intermediateTokenAmount = swapResult.amountsAndCosts.afterSlippage.buyAmount;
+  log2(
+    `Expected to receive ${intermediateTokenAmount} of the intermediate token (${adapter.utils.parseUnits(intermediateTokenAmount.toString(), intermediaryTokenDecimals).toString()})`
+  );
+  async function signHooksAndSetSwapResult(signer2, defaultGasLimit, advancedSettings2) {
+    const appDataOverride = advancedSettings2?.appData;
+    const receiverOverride = advancedSettings2?.quoteRequest?.receiver;
+    const {
+      bridgeHook,
+      appDataInfo: { doc: appData, fullAppData, appDataKeccak256 },
+      bridgeResult
+    } = await getBridgeResult({
+      swapAndBridgeRequest: { ...swapAndBridgeRequest, kind: OrderKind.SELL },
+      swapResult,
+      bridgeRequestWithoutAmount: {
+        ...bridgeRequestWithoutAmount,
+        receiver: receiverOverride || bridgeRequestWithoutAmount.receiver
+      },
+      provider,
+      intermediateTokenAmount,
+      signer: signer2,
+      mockedHook,
+      appDataOverride,
+      defaultGasLimit
+    });
+    log2(`Bridge hook for swap: ${JSON.stringify(bridgeHook)}`);
+    swapResult.tradeParameters.receiver = bridgeHook.recipient;
+    log2(`App data for swap: appDataKeccak256=${appDataKeccak256}, fullAppData="${fullAppData}"`);
+    swapResult.appDataInfo = {
+      fullAppData,
+      appDataKeccak256,
+      doc: appData
+    };
+    return {
+      bridgeResult,
+      swapResult: {
+        ...swapResult,
+        tradeParameters: {
+          ...swapResult.tradeParameters,
+          receiver: bridgeHook.recipient
+        }
+      }
+    };
+  }
+  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
+    bridgeHookSigner ? BigInt(hookEstimatedGasLimit) : void 0
+  );
+  return {
+    swap: result.swapResult,
+    bridge: result.bridgeResult,
+    async postSwapOrderFromQuote(advancedSettings2) {
+      const { swapResult: swapResult2 } = await signHooksAndSetSwapResult(signer, void 0, advancedSettings2);
+      const quoteResults = {
+        result: {
+          ...swapResult2,
+          tradeParameters: getTradeParametersAfterQuote({
+            quoteParameters: swapResult2.tradeParameters,
+            sellToken: sellTokenAddress
+          }),
+          signer
+        },
+        orderBookApi
+      };
+      return postSwapOrderFromQuote(quoteResults, {
+        ...advancedSettings2,
+        appData: swapResult2.appDataInfo.doc,
+        quoteRequest: {
+          ...advancedSettings2?.quoteRequest,
+          // Changing receiver back to account proxy
+          receiver: swapResult2.tradeParameters.receiver
+        }
+      });
+    }
+  };
+}
+async function getBaseBridgeQuoteRequest(params) {
+  const { provider, getErc20Decimals, swapAndBridgeRequest: quoteBridgeRequest } = params;
+  const { sellTokenChainId } = quoteBridgeRequest;
+  const intermediateTokens = await provider.getIntermediateTokens(quoteBridgeRequest);
+  const intermediateTokenAddress = intermediateTokens[0];
+  log2(`Using ${intermediateTokenAddress} as intermediate tokens`);
+  if (!intermediateTokenAddress) {
+    throw new BridgeProviderQuoteError("No path found (not intermediate token for bridging)", {});
+  }
+  const intermediaryTokenDecimals = await getErc20Decimals(sellTokenChainId, intermediateTokenAddress);
+  return {
+    ...quoteBridgeRequest,
+    sellTokenAddress: intermediateTokenAddress,
+    sellTokenDecimals: intermediaryTokenDecimals
+  };
+}
+async function getBridgeResult(context) {
+  const {
+    swapResult,
+    bridgeRequestWithoutAmount,
+    provider,
+    intermediateTokenAmount,
+    signer,
+    mockedHook,
+    appDataOverride,
+    defaultGasLimit
+  } = context;
+  const bridgeRequest = {
+    ...bridgeRequestWithoutAmount,
+    amount: intermediateTokenAmount
+  };
+  const bridgingQuote = await provider.getQuote(bridgeRequest);
+  const unsignedBridgeCall = await provider.getUnsignedBridgeCall(bridgeRequest, bridgingQuote);
+  const bridgeHook = await provider.getSignedHook(
+    bridgeRequest.sellTokenChainId,
+    unsignedBridgeCall,
+    defaultGasLimit,
+    signer
+  );
+  const swapAppData = await mergeAppDataDoc(swapResult.appDataInfo.doc, appDataOverride || {});
+  const swapResultHooks = swapAppData.doc.metadata.hooks;
+  const postHooks = swapResultHooks?.post || [];
+  const isBridgeHookAlreadyPresent = postHooks.some((hook) => areHooksEqual(hook, bridgeHook.postHook));
+  const appDataInfo = await mergeAppDataDoc(swapAppData.doc, {
+    metadata: {
+      hooks: {
+        pre: swapResultHooks?.pre,
+        // Remove the mocked hook from the post hooks after receiving quote
+        post: [...swapResultHooks?.post || [], ...isBridgeHookAlreadyPresent ? [] : [bridgeHook.postHook]].filter(
+          (hook) => !areHooksEqual(hook, mockedHook)
+        )
+      }
+    }
+  });
+  const bridgeResult = {
+    providerInfo: provider.info,
+    tradeParameters: bridgeRequest,
+    // Just the bridge (not the swap & bridge)
+    bridgeCallDetails: {
+      unsignedBridgeCall,
+      preAuthorizedBridgingHook: bridgeHook
+    },
+    isSell: bridgingQuote.isSell,
+    expectedFillTimeSeconds: bridgingQuote.expectedFillTimeSeconds,
+    fees: bridgingQuote.fees,
+    limits: bridgingQuote.limits,
+    quoteTimestamp: bridgingQuote.quoteTimestamp,
+    amountsAndCosts: bridgingQuote.amountsAndCosts
+  };
+  return { bridgeResult, bridgeHook, appDataInfo };
+}
+
+// src/BridgingSdk/getErc20Decimals.ts
+import { getGlobalAdapter as getGlobalAdapter2 } from "@cowprotocol/sdk-common";
+var ERC20_DECIMALS_ABI = ["function decimals() external view returns (uint8)"];
+function factoryGetErc20Decimals() {
+  return (_chainId, tokenAddress) => {
+    const adapter = getGlobalAdapter2();
+    const contract = adapter.getContract(tokenAddress, ERC20_DECIMALS_ABI);
+    return contract.decimals();
+  };
+}
+
+// src/BridgingSdk/BridgingSdk.ts
+import { CowError, enableLogging, setGlobalAdapter } from "@cowprotocol/sdk-common";
+import { OrderBookApi } from "@cowprotocol/sdk-order-book";
+
+// src/providers/across/const/misc.ts
+var HOOK_DAPP_BRIDGE_PROVIDER_PREFIX = "cow-sdk://bridging/providers";
+
+// src/BridgingSdk/getCrossChainOrder.ts
+async function getCrossChainOrder(params) {
+  const { orderId, chainId, orderBookApi, providers, env } = params;
+  const chainContext = { chainId, env };
+  const order = await orderBookApi.getOrder(orderId, chainContext);
+  const postHooks = getPostHooks(order.fullAppData ?? void 0);
+  const bridgingHook = postHooks.find((hook) => {
+    return hook.dappId?.startsWith(HOOK_DAPP_BRIDGE_PROVIDER_PREFIX);
+  });
+  if (!bridgingHook) {
+    throw new Error(`Order ${orderId} is not a cross-chain order`);
+  }
+  const bridgeProviderName = bridgingHook.dappId?.split(HOOK_DAPP_BRIDGE_PROVIDER_PREFIX).pop();
+  const provider = providers.find((provider2) => provider2.info.name === bridgeProviderName);
+  if (!provider) {
+    throw new Error(
+      `Unknown Bridge provider: ${bridgeProviderName}. 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];
+    if (!firstTrade?.txHash) {
+      throw new Error(`No tx hash found for order ${orderId} . First trade, with log index ${firstTrade?.logIndex}`);
+    }
+    const bridgingId = await provider.getBridgingId(orderId, firstTrade.txHash, firstTrade.logIndex);
+    const { status, fillTimeInSeconds } = await provider.getStatus(bridgingId);
+    const explorerUrl = provider.getExplorerUrl(bridgingId);
+    return {
+      chainId,
+      order,
+      status,
+      bridgingId,
+      explorerUrl,
+      fillTimeInSeconds
+    };
+  } else {
+    return {
+      chainId,
+      order,
+      status: "not_initiated" /* NOT_INITIATED */
+    };
+  }
+}
+
+// src/BridgingSdk/BridgingSdk.ts
+var BridgingSdk = class {
+  constructor(options, adapter) {
+    this.options = options;
+    if (adapter) {
+      setGlobalAdapter(adapter);
+    }
+    const { providers, ...restOptions } = options;
+    if (!providers || providers.length !== 1) {
+      throw new Error("Current implementation only supports a single bridge provider");
+    }
+    if (options.enableLogging !== void 0) {
+      enableLogging(options.enableLogging);
+    }
+    const tradingSdk = options.tradingSdk ?? new TradingSdk2();
+    const orderBookApi = tradingSdk?.options.orderBookApi ?? new OrderBookApi();
+    this.config = {
+      ...restOptions,
+      providers,
+      tradingSdk,
+      orderBookApi
+    };
+  }
+  config;
+  get provider() {
+    const { providers } = this.config;
+    if (!providers[0]) {
+      throw new CowError("No provider found");
+    }
+    return providers[0];
+  }
+  /**
+   * Get the providers for the bridging.
+   */
+  getProviders() {
+    return this.config.providers;
+  }
+  /**
+   * Get the available sources networks for the bridging.
+   */
+  async getSourceNetworks() {
+    return ALL_SUPPORTED_CHAINS;
+  }
+  /**
+   * Get the available target networks for the bridging.
+   */
+  async getTargetNetworks() {
+    return this.provider.getNetworks();
+  }
+  /**
+   * Get the available buy tokens for buying in a specific target chain
+   *
+   * @param param
+   * @returns
+   */
+  async getBuyTokens(targetChainId) {
+    return this.provider.getBuyTokens(targetChainId);
+  }
+  /**
+   * Get quote details, including a callback function to post the order on-chain.
+   *
+   * This method support both, cross-chain swaps and single-chain swap.
+   *
+   * The return type will be either `QuoteAndPost` or `BridgeQuoteAndPost`.
+   *
+   * To safely assert the type in Typescript, you can use:
+   * - `isBridgeQuoteAndPost(result)` utility.
+   * - `isQuoteAndPost(result)` utility.
+   * - `assertIsBridgeQuoteAndPost(result)` assertion.
+   * - `assertIsQuoteAndPost(result)` assertion.
+   *
+   * @throws Error if no path is found
+   */
+  async getQuote(quoteBridgeRequest, advancedSettings) {
+    const { sellTokenChainId, buyTokenChainId } = quoteBridgeRequest;
+    const tradingSdk = this.config.tradingSdk;
+    if (sellTokenChainId !== buyTokenChainId) {
+      const getErc20Decimals = this.config.getErc20Decimals ?? factoryGetErc20Decimals();
+      return getQuoteWithBridge({
+        swapAndBridgeRequest: quoteBridgeRequest,
+        advancedSettings,
+        tradingSdk,
+        provider: this.provider,
+        getErc20Decimals,
+        bridgeHookSigner: advancedSettings?.quoteSigner
+      });
+    } else {
+      return getQuoteWithoutBridge({
+        quoteBridgeRequest,
+        advancedSettings,
+        tradingSdk
+      });
+    }
+  }
+  async getOrder(params) {
+    const { orderBookApi } = this.config;
+    const { orderId, chainId, env } = params;
+    return getCrossChainOrder({
+      orderId,
+      chainId,
+      orderBookApi,
+      providers: this.config.providers,
+      env: env || orderBookApi.context.env
+    });
+  }
+};
+
+// src/providers/mock/MockBridgeProvider.ts
+import { OrderKind as OrderKind2 } from "@cowprotocol/sdk-order-book";
+import {
+  sepolia,
+  optimism,
+  mainnet,
+  AdditionalTargetChainId,
+  SupportedChainId as SupportedChainId2
+} from "@cowprotocol/sdk-config";
+
+// 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 = 2e5;
+
+// src/providers/mock/MockBridgeProvider.ts
+var BRIDGING_ID = "123456789asdfg";
+var MOCK_CALL = {
+  to: "0x0000000000000000000000000000000000000001",
+  data: "0x0",
+  value: BigInt(0)
+};
+var BUY_TOKENS = [
+  {
+    chainId: SupportedChainId2.MAINNET,
+    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    logoUrl: "https://swap.cow.fi/assets/network-mainnet-logo-BJe1wK_m.svg",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6
+  },
+  {
+    chainId: SupportedChainId2.MAINNET,
+    address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    logoUrl: "https://swap.cow.fi/assets/network-gnosis-chain-logo-Do_DEWQv.svg",
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    decimals: 18
+  },
+  {
+    chainId: SupportedChainId2.SEPOLIA,
+    address: "0x0625aFB445C3B6B7B929342a04A22599fd5dBB59",
+    logoUrl: "https://swap.cow.fi/assets/network-mainnet-logo-BJe1wK_m.svg",
+    name: "CoW Protocol Token",
+    symbol: "COW",
+    decimals: 18
+  },
+  {
+    chainId: AdditionalTargetChainId.OPTIMISM,
+    address: "0x4200000000000000000000000000000000000006",
+    logoUrl: "https://swap.cow.fi/assets/network-mainnet-logo-BJe1wK_m.svg",
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    decimals: 18
+  }
+];
+var INTERMEDIATE_TOKENS = {
+  [SupportedChainId2.MAINNET]: ["0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB"],
+  [AdditionalTargetChainId.OPTIMISM]: ["0x68f180fcCe6836688e9084f035309E29Bf0A2095"],
+  [SupportedChainId2.SEPOLIA]: ["0xB4F1737Af37711e9A5890D9510c9bB60e170CB0D"]
+};
+var MockBridgeProvider = class {
+  info = {
+    name: "Mock",
+    logoUrl: `${RAW_PROVIDERS_FILES_PATH}/mock/mock-logo.png`
+  };
+  async getNetworks() {
+    return [mainnet, optimism, sepolia];
+  }
+  async getBuyTokens(targetChainId) {
+    return BUY_TOKENS.filter((token) => token.chainId === targetChainId);
+  }
+  async getIntermediateTokens({ sellTokenChainId }) {
+    return INTERMEDIATE_TOKENS[sellTokenChainId] ?? [];
+  }
+  async getQuote(_request) {
+    return {
+      isSell: true,
+      amountsAndCosts: {
+        costs: {
+          bridgingFee: {
+            feeBps: 10,
+            amountInSellCurrency: 123456n,
+            amountInBuyCurrency: 123456n
+          }
+        },
+        beforeFee: {
+          sellAmount: 123456n,
+          buyAmount: 123456n
+        },
+        afterFee: {
+          sellAmount: 123456n,
+          buyAmount: 123456n
+        },
+        afterSlippage: {
+          sellAmount: 123456n,
+          buyAmount: 123456n
+        },
+        slippageBps: 0
+      },
+      quoteTimestamp: Date.now(),
+      expectedFillTimeSeconds: 128,
+      fees: {
+        bridgeFee: 1n,
+        destinationGasFee: 2n
+      },
+      limits: {
+        minDeposit: 1n,
+        maxDeposit: 100000n
+      }
+    };
+  }
+  getGasLimitEstimationForHook(_request) {
+    return 11e4;
+  }
+  async getUnsignedBridgeCall(_request, _quote) {
+    return MOCK_CALL;
+  }
+  async getSignedHook(_chainId, _unsignedCall, _signer) {
+    return {
+      recipient: "0x0000000000000000000000000000000000000001",
+      postHook: {
+        target: "0x0000000000000000000000000000000000000002",
+        callData: "0x1",
+        gasLimit: "0x2",
+        dappId: "MockBridgeProvider"
+      }
+    };
+  }
+  async decodeBridgeHook(_hook) {
+    return {
+      kind: OrderKind2.SELL,
+      provider: this.info,
+      account: "0x0000000000000000000000000000000000000001",
+      sellTokenChainId: 1,
+      sellTokenAddress: "0x0000000000000000000000000000000000000001",
+      sellTokenAmount: "123456",
+      sellTokenDecimals: 18,
+      buyTokenChainId: 1,
+      buyTokenAddress: "0x0000000000000000000000000000000000000002",
+      buyTokenDecimals: 18,
+      minBuyAmount: "123456",
+      receiver: "0x0000000000000000000000000000000000000001",
+      signer: "",
+      appCode: "MOCK"
+    };
+  }
+  async getBridgingId(_orderUid, _settlementTx, _logIndex) {
+    return BRIDGING_ID;
+  }
+  getExplorerUrl(bridgingId) {
+    return "https://www.google.com/search?q=" + bridgingId;
+  }
+  async getStatus(_bridgingId) {
+    return {
+      status: "in_progress" /* IN_PROGRESS */,
+      fillTimeInSeconds: 67
+    };
+  }
+  async getCancelBridgingTx(_bridgingId) {
+    return MOCK_CALL;
+  }
+  async getRefundBridgingTx(_bridgingId) {
+    return MOCK_CALL;
+  }
+};
+
+// src/providers/across/AcrossBridgeProvider.ts
+import { setGlobalAdapter as setGlobalAdapter2 } from "@cowprotocol/sdk-common";
+import {
+  mainnet as mainnet2,
+  polygon,
+  arbitrumOne,
+  base,
+  optimism as optimism2
+} from "@cowprotocol/sdk-config";
+
+// src/providers/across/const/tokens.ts
+import { SupportedChainId as SupportedChainId3, AdditionalTargetChainId as AdditionalTargetChainId2 } from "@cowprotocol/sdk-config";
+var ACROSS_CHAIN_CONFIGS = [
+  {
+    chainId: SupportedChainId3.MAINNET,
+    tokens: {
+      usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+      wbtc: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+      dai: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+      usdt: "0xdAC17F958D2ee523a2206206994597C13D831ec7"
+    }
+  },
+  {
+    chainId: SupportedChainId3.POLYGON,
+    tokens: {
+      usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+      weth: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
+      wbtc: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
+      dai: "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
+      usdt: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F"
+    }
+  },
+  {
+    chainId: SupportedChainId3.ARBITRUM_ONE,
+    tokens: {
+      usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+      weth: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+      wbtc: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
+      dai: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+      usdt: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"
+    }
+  },
+  {
+    chainId: SupportedChainId3.BASE,
+    tokens: {
+      usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      weth: "0x4200000000000000000000000000000000000006",
+      dai: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+    }
+  },
+  {
+    chainId: AdditionalTargetChainId2.OPTIMISM,
+    tokens: {
+      usdc: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+      weth: "0x4200000000000000000000000000000000000006",
+      wbtc: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
+      dai: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+      usdt: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58"
+    }
+  }
+];
+var ACROSS_TOKEN_MAPPING = ACROSS_CHAIN_CONFIGS.reduce(
+  (acc, config) => {
+    acc[config.chainId] = config;
+    return acc;
+  },
+  {}
+);
+
+// src/providers/across/AcrossApi.ts
+import { log as log3 } from "@cowprotocol/sdk-common";
+var ACROSS_API_URL = "https://app.across.to/api";
+var AcrossApi = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Retrieve available routes for transfers
+   *
+   * Returns available routes based on specified parameters. If no parameters are provided, available routes on all
+   * chains are returned.
+   *
+   * See https://docs.across.to/reference/api-reference#available-routes
+   */
+  async getAvailableRoutes({
+    originChainId,
+    originToken,
+    destinationChainId,
+    destinationToken
+  }) {
+    const params = {};
+    if (originChainId)
+      params.originChainId = originChainId;
+    if (originToken)
+      params.originToken = originToken;
+    if (destinationChainId)
+      params.destinationChainId = destinationChainId;
+    if (destinationToken)
+      params.destinationToken = destinationToken;
+    return this.fetchApi("/available-routes", params, isValidRoutes);
+  }
+  /**
+   * Retrieve suggested fee quote for a deposit.
+   *
+   * Returns suggested fees based inputToken+outputToken, originChainId, destinationChainId, and amount.
+   * Also includes data used to compute the fees.
+   *
+   * * See https://docs.across.to/reference/api-reference#suggested-fees
+   */
+  async getSuggestedFees(request) {
+    const params = {
+      token: request.token,
+      originChainId: request.originChainId.toString(),
+      destinationChainId: request.destinationChainId.toString(),
+      amount: request.amount.toString()
+    };
+    if (request.recipient) {
+      params.recipient = request.recipient;
+    }
+    return this.fetchApi("/suggested-fees", params, isValidSuggestedFeesResponse);
+  }
+  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)}`);
+    const response = await fetch(url, {
+      method: "GET"
+    });
+    if (!response.ok) {
+      const errorBody = await response.json();
+      throw new BridgeProviderQuoteError("Across Api Error", errorBody);
+    }
+    const json = await response.json();
+    if (isValidResponse) {
+      if (isValidResponse(json)) {
+        return json;
+      } else {
+        throw new BridgeProviderQuoteError(
+          `Invalid response for Across API call ${path}. The response doesn't pass the validation. Did the API change?`,
+          json
+        );
+      }
+    }
+    return json;
+  }
+};
+function isValidSuggestedFeesResponse(response) {
+  return typeof response === "object" && response !== null && "totalRelayFee" in response && isValidPctFee(response.totalRelayFee) && "relayerCapitalFee" in response && isValidPctFee(response.relayerCapitalFee) && "relayerGasFee" in response && isValidPctFee(response.relayerGasFee) && "lpFee" in response && isValidPctFee(response.lpFee) && "timestamp" in response && "isAmountTooLow" in response && "quoteBlock" in response && "spokePoolAddress" in response && "exclusiveRelayer" in response && "exclusivityDeadline" in response && "estimatedFillTimeSec" in response && "fillDeadline" in response && "limits" in response && isValidSuggestedFeeLimits(response.limits);
+}
+function isValidPctFee(pctFee) {
+  return typeof pctFee === "object" && pctFee !== null && "pct" in pctFee && "total" in pctFee;
+}
+function isValidSuggestedFeeLimits(limits) {
+  return typeof limits === "object" && limits !== null && "minDeposit" in limits && "maxDeposit" in limits && "maxDepositInstant" in limits && "maxDepositShortDelay" in limits && "recommendedDepositInstant" in limits;
+}
+function isValidRoutes(response) {
+  if (!Array.isArray(response)) {
+    return false;
+  }
+  return response.every((item) => isValidRoute(item));
+}
+function isValidRoute(item) {
+  return typeof item === "object" && item !== null && "originChainId" in item && "originToken" in item && "destinationChainId" in item && "destinationToken" in item && "originTokenSymbol" in item && "destinationTokenSymbol" in item;
+}
+
+// src/providers/across/util.ts
+import { getBigNumber } from "@cowprotocol/sdk-order-book";
+import { ContractsOrderKind as OrderKind3 } from "@cowprotocol/sdk-contracts-ts";
+var PCT_100_PERCENT = 10n ** 18n;
+function getChainConfigs(sourceChainId, targetChainId) {
+  const sourceChainConfig = getChainConfig(sourceChainId);
+  const targetChainConfig = getChainConfig(targetChainId);
+  if (!sourceChainConfig || !targetChainConfig)
+    return;
+  return { sourceChainConfig, targetChainConfig };
+}
+function getChainConfig(chainId) {
+  return ACROSS_TOKEN_MAPPING[chainId];
+}
+function getTokenSymbol(tokenAddress, chainConfig) {
+  return Object.keys(chainConfig.tokens).find((key) => chainConfig.tokens[key] === tokenAddress);
+}
+function getTokenAddress(tokenSymbol, chainConfig) {
+  return chainConfig.tokens[tokenSymbol];
+}
+function toBridgeQuoteResult(request, slippageBps, suggestedFees) {
+  const { kind } = request;
+  return {
+    isSell: kind === OrderKind3.SELL,
+    amountsAndCosts: toAmountsAndCosts(request, slippageBps, suggestedFees),
+    quoteTimestamp: Number(suggestedFees.timestamp),
+    expectedFillTimeSeconds: Number(suggestedFees.estimatedFillTimeSec),
+    fees: {
+      bridgeFee: BigInt(suggestedFees.relayerCapitalFee.total),
+      destinationGasFee: BigInt(suggestedFees.relayerGasFee.total)
+    },
+    limits: {
+      minDeposit: BigInt(suggestedFees.limits.minDeposit),
+      maxDeposit: BigInt(suggestedFees.limits.maxDeposit)
+    },
+    suggestedFees
+  };
+}
+function toAmountsAndCosts(request, slippageBps, suggestedFees) {
+  const { amount, sellTokenDecimals, buyTokenDecimals } = request;
+  const sellAmountBeforeFeeBig = getBigNumber(amount, sellTokenDecimals);
+  const sellAmountBeforeFee = sellAmountBeforeFeeBig.big;
+  const buyAmountBeforeFee = getBigNumber(sellAmountBeforeFeeBig.num, buyTokenDecimals).big;
+  const totalRelayerFeePct = BigInt(suggestedFees.totalRelayFee.pct);
+  const buyAmountAfterFee = applyPctFee(buyAmountBeforeFee, totalRelayerFeePct);
+  const feeSellToken = sellAmountBeforeFee - applyPctFee(sellAmountBeforeFee, totalRelayerFeePct);
+  const feeBuyToken = buyAmountBeforeFee - buyAmountAfterFee;
+  const buyAmountAfterSlippage = applyBps(buyAmountAfterFee, slippageBps);
+  return {
+    beforeFee: {
+      sellAmount: sellAmountBeforeFee,
+      buyAmount: buyAmountBeforeFee
+      // Assuming the price is 1:1 (before fee). This is because we are exchanging the same asset
+    },
+    afterFee: {
+      sellAmount: sellAmountBeforeFee,
+      // Sell amount does't change (fee is applied to the buy amount)
+      buyAmount: buyAmountAfterFee
+    },
+    afterSlippage: {
+      sellAmount: sellAmountBeforeFee,
+      // Sell amount does't change (slippage is applied to the buy amount)
+      buyAmount: buyAmountAfterSlippage
+    },
+    costs: {
+      bridgingFee: {
+        feeBps: pctToBps(totalRelayerFeePct),
+        amountInSellCurrency: feeSellToken,
+        amountInBuyCurrency: feeBuyToken
+      }
+    },
+    slippageBps
+  };
+}
+function assertValidPct(pct) {
+  if (pct > PCT_100_PERCENT || pct < 0n) {
+    throw new Error("Fee cannot exceed 100% or be negative");
+  }
+}
+function pctToBps(pct) {
+  assertValidPct(pct);
+  return Number(pct * 10000n / PCT_100_PERCENT);
+}
+function applyPctFee(amount, pct) {
+  assertValidPct(pct);
+  return amount * (PCT_100_PERCENT - pct) / PCT_100_PERCENT;
+}
+function applyBps(amount, bps) {
+  return amount * BigInt(1e4 - bps) / 10000n;
+}
+
+// src/providers/across/AcrossBridgeProvider.ts
+import { CowShedSdk } from "@cowprotocol/sdk-cow-shed";
+
+// src/providers/across/const/contracts.ts
+import { AdditionalTargetChainId as AdditionalTargetChainId3, SupportedChainId as SupportedChainId4 } from "@cowprotocol/sdk-config";
+var ACROSS_SPOOK_CONTRACT_ADDRESSES = {
+  // https://docs.across.to/reference/contract-addresses/mainnet-chain-id-1
+  [SupportedChainId4.MAINNET]: "0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5",
+  // https://docs.across.to/reference/contract-addresses/arbitrum-chain-id-42161-1
+  [SupportedChainId4.ARBITRUM_ONE]: "0xe35e9842fceaca96570b734083f4a58e8f7c5f2a",
+  // https://docs.across.to/reference/contract-addresses/base-chain-id-8453
+  [SupportedChainId4.BASE]: "0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64",
+  // // https://docs.across.to/reference/contract-addresses/mainnet-chain-id-1
+  [SupportedChainId4.SEPOLIA]: "0x5ef6C01E11889d86803e0B23e3cB3F9E9d97B662",
+  // https://docs.across.to/reference/contract-addresses/polygon-chain-id-137
+  [SupportedChainId4.POLYGON]: "0x9295ee1d8C5b022Be115A2AD3c30C72E34e7F096",
+  // Not supported chains
+  // TODO: This first integration is a draft, some of this chains might be supported, so we will need to update here as we iterate on the provider
+  [SupportedChainId4.GNOSIS_CHAIN]: void 0,
+  [SupportedChainId4.AVALANCHE]: void 0,
+  [AdditionalTargetChainId3.OPTIMISM]: void 0
+};
+var ACROSS_MATH_CONTRACT_ADDRESSES = {
+  [SupportedChainId4.MAINNET]: "0xf2ae6728b6f146556977Af0A68bFbf5bADA22863",
+  [SupportedChainId4.ARBITRUM_ONE]: "0x5771A4b4029832e79a75De7B485E5fBbec28848f",
+  [SupportedChainId4.BASE]: "0xd4e943dc6ddc885f6229ce33c2e3dfe402a12c81",
+  // Not supported chains
+  // TODO: This first integration is a draft, some of this chains might be supported, so we will need to update here as we iterate on the provider
+  [SupportedChainId4.GNOSIS_CHAIN]: void 0,
+  [SupportedChainId4.SEPOLIA]: void 0,
+  [SupportedChainId4.POLYGON]: void 0,
+  [AdditionalTargetChainId3.OPTIMISM]: void 0,
+  [SupportedChainId4.AVALANCHE]: void 0
+};
+
+// src/providers/across/createAcrossDepositCall.ts
+import { WeirollCommandFlags, createWeirollContract, createWeirollDelegateCall } from "@cowprotocol/sdk-weiroll";
+
+// src/providers/across/abi.ts
+var ACROSS_MATH_ABI = [
+  {
+    inputs: [
+      { internalType: "uint256", name: "_a", type: "uint256" },
+      { internalType: "uint256", name: "_b", type: "uint256" }
+    ],
+    name: "multiplyAndSubtract",
+    outputs: [{ internalType: "uint256", name: "result", type: "uint256" }],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
+var ACROSS_SPOKE_POOL_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_wrappedNativeTokenAddress",
+        type: "address"
+      },
+      {
+        internalType: "uint32",
+        name: "_depositQuoteTimeBuffer",
+        type: "uint32"
+      },
+      { internalType: "uint32", name: "_fillDeadlineBuffer", type: "uint32" }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  { inputs: [], name: "ClaimedMerkleLeaf", type: "error" },
+  { inputs: [], name: "DepositsArePaused", type: "error" },
+  { inputs: [], name: "DisabledRoute", type: "error" },
+  { inputs: [], name: "ExpiredFillDeadline", type: "error" },
+  { inputs: [], name: "FillsArePaused", type: "error" },
+  {
+    inputs: [],
+    name: "InsufficientSpokePoolBalanceToExecuteLeaf",
+    type: "error"
+  },
+  { inputs: [], name: "InvalidBytes32", type: "error" },
+  { inputs: [], name: "InvalidChainId", type: "error" },
+  { inputs: [], name: "InvalidCrossDomainAdmin", type: "error" },
+  { inputs: [], name: "InvalidDepositorSignature", type: "error" },
+  { inputs: [], name: "InvalidExclusiveRelayer", type: "error" },
+  { inputs: [], name: "InvalidFillDeadline", type: "error" },
+  { inputs: [], name: "InvalidMerkleLeaf", type: "error" },
+  { inputs: [], name: "InvalidMerkleProof", type: "error" },
+  { inputs: [], name: "InvalidPayoutAdjustmentPct", type: "error" },
+  { inputs: [], name: "InvalidQuoteTimestamp", type: "error" },
+  { inputs: [], name: "InvalidRelayerFeePct", type: "error" },
+  { inputs: [], name: "InvalidSlowFillRequest", type: "error" },
+  { inputs: [], name: "InvalidWithdrawalRecipient", type: "error" },
+  {
+    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
+    name: "LowLevelCallFailed",
+    type: "error"
+  },
+  { inputs: [], name: "MaxTransferSizeExceeded", type: "error" },
+  { inputs: [], name: "MsgValueDoesNotMatchInputAmount", type: "error" },
+  { inputs: [], name: "NoRelayerRefundToClaim", type: "error" },
+  { inputs: [], name: "NoSlowFillsInExclusivityWindow", type: "error" },
+  { inputs: [], name: "NotEOA", type: "error" },
+  { inputs: [], name: "NotExclusiveRelayer", type: "error" },
+  { inputs: [], name: "RelayFilled", type: "error" },
+  { inputs: [], name: "WrongERC7683OrderId", type: "error" },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "previousAdmin",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "newAdmin",
+        type: "address"
+      }
+    ],
+    name: "AdminChanged",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "beacon",
+        type: "address"
+      }
+    ],
+    name: "BeaconUpgraded",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "l2TokenAddress",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "refundAddress",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "caller",
+        type: "address"
+      }
+    ],
+    name: "ClaimedRelayerRefund",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "rootBundleId",
+        type: "uint256"
+      }
+    ],
+    name: "EmergencyDeletedRootBundle",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "originToken",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "destinationChainId",
+        type: "uint256"
+      },
+      { indexed: false, internalType: "bool", name: "enabled", type: "bool" }
+    ],
+    name: "EnabledDepositRoute",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amountToReturn",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "chainId",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256[]",
+        name: "refundAmounts",
+        type: "uint256[]"
+      },
+      {
+        indexed: true,
+        internalType: "uint32",
+        name: "rootBundleId",
+        type: "uint32"
+      },
+      { indexed: true, internalType: "uint32", name: "leafId", type: "uint32" },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "l2TokenAddress",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address[]",
+        name: "refundAddresses",
+        type: "address[]"
+      },
+      {
+        indexed: false,
+        internalType: "bool",
+        name: "deferredRefunds",
+        type: "bool"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "caller",
+        type: "address"
+      }
+    ],
+    name: "ExecutedRelayerRefundRoot",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "inputToken",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "outputToken",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "inputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "outputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "repaymentChainId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "originChainId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "depositId",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "fillDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "exclusivityDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "exclusiveRelayer",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "relayer",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "depositor",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "recipient",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "messageHash",
+        type: "bytes32"
+      },
+      {
+        components: [
+          {
+            internalType: "bytes32",
+            name: "updatedRecipient",
+            type: "bytes32"
+          },
+          {
+            internalType: "bytes32",
+            name: "updatedMessageHash",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint256",
+            name: "updatedOutputAmount",
+            type: "uint256"
+          },
+          {
+            internalType: "enum V3SpokePoolInterface.FillType",
+            name: "fillType",
+            type: "uint8"
+          }
+        ],
+        indexed: false,
+        internalType: "struct V3SpokePoolInterface.V3RelayExecutionEventInfo",
+        name: "relayExecutionInfo",
+        type: "tuple"
+      }
+    ],
+    name: "FilledRelay",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "inputToken",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "outputToken",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "inputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "outputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "repaymentChainId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "originChainId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint32",
+        name: "depositId",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "fillDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "exclusivityDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "exclusiveRelayer",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "relayer",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "depositor",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "recipient",
+        type: "address"
+      },
+      { indexed: false, internalType: "bytes", name: "message", type: "bytes" },
+      {
+        components: [
+          {
+            internalType: "address",
+            name: "updatedRecipient",
+            type: "address"
+          },
+          { internalType: "bytes", name: "updatedMessage", type: "bytes" },
+          {
+            internalType: "uint256",
+            name: "updatedOutputAmount",
+            type: "uint256"
+          },
+          {
+            internalType: "enum V3SpokePoolInterface.FillType",
+            name: "fillType",
+            type: "uint8"
+          }
+        ],
+        indexed: false,
+        internalType: "struct V3SpokePoolInterface.LegacyV3RelayExecutionEventInfo",
+        name: "relayExecutionInfo",
+        type: "tuple"
+      }
+    ],
+    name: "FilledV3Relay",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "inputToken",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "outputToken",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "inputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "outputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "destinationChainId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "depositId",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "quoteTimestamp",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "fillDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "exclusivityDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "depositor",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "recipient",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "exclusiveRelayer",
+        type: "bytes32"
+      },
+      { indexed: false, internalType: "bytes", name: "message", type: "bytes" }
+    ],
+    name: "FundsDeposited",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, internalType: "uint8", name: "version", type: "uint8" }],
+    name: "Initialized",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, internalType: "bool", name: "isPaused", type: "bool" }],
+    name: "PausedDeposits",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, internalType: "bool", name: "isPaused", type: "bool" }],
+    name: "PausedFills",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint32",
+        name: "rootBundleId",
+        type: "uint32"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "relayerRefundRoot",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "slowRelayRoot",
+        type: "bytes32"
+      }
+    ],
+    name: "RelayedRootBundle",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "inputToken",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "outputToken",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "inputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "outputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "originChainId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "depositId",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "fillDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "exclusivityDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "exclusiveRelayer",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "depositor",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "recipient",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "messageHash",
+        type: "bytes32"
+      }
+    ],
+    name: "RequestedSlowFill",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "updatedOutputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "depositId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "depositor",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes32",
+        name: "updatedRecipient",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "updatedMessage",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "depositorSignature",
+        type: "bytes"
+      }
+    ],
+    name: "RequestedSpeedUpDeposit",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "updatedOutputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint32",
+        name: "depositId",
+        type: "uint32"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "depositor",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "updatedRecipient",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "updatedMessage",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "depositorSignature",
+        type: "bytes"
+      }
+    ],
+    name: "RequestedSpeedUpV3Deposit",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "inputToken",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "outputToken",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "inputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "outputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "originChainId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint32",
+        name: "depositId",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "fillDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "exclusivityDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "exclusiveRelayer",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "depositor",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "recipient",
+        type: "address"
+      },
+      { indexed: false, internalType: "bytes", name: "message", type: "bytes" }
+    ],
+    name: "RequestedV3SlowFill",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newWithdrawalRecipient",
+        type: "address"
+      }
+    ],
+    name: "SetWithdrawalRecipient",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newAdmin",
+        type: "address"
+      }
+    ],
+    name: "SetXDomainAdmin",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amountToReturn",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "chainId",
+        type: "uint256"
+      },
+      { indexed: true, internalType: "uint32", name: "leafId", type: "uint32" },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "l2TokenAddress",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "caller",
+        type: "address"
+      }
+    ],
+    name: "TokensBridged",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "implementation",
+        type: "address"
+      }
+    ],
+    name: "Upgraded",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "inputToken",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "outputToken",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "inputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "outputAmount",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "destinationChainId",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "uint32",
+        name: "depositId",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "quoteTimestamp",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "fillDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "exclusivityDeadline",
+        type: "uint32"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "depositor",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "recipient",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "exclusiveRelayer",
+        type: "address"
+      },
+      { indexed: false, internalType: "bytes", name: "message", type: "bytes" }
+    ],
+    name: "V3FundsDeposited",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "EMPTY_RELAYER",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "EMPTY_REPAYMENT_CHAIN_ID",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "INFINITE_FILL_DEADLINE",
+    outputs: [{ internalType: "uint32", name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "MAX_EXCLUSIVITY_PERIOD_SECONDS",
+    outputs: [{ internalType: "uint32", name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "MAX_TRANSFER_SIZE",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "UPDATE_ADDRESS_DEPOSIT_DETAILS_HASH",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "UPDATE_BYTES32_DEPOSIT_DETAILS_HASH",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint32", name: "_initialDepositId", type: "uint32" },
+      { internalType: "address", name: "_crossDomainAdmin", type: "address" },
+      {
+        internalType: "address",
+        name: "_withdrawalRecipient",
+        type: "address"
+      }
+    ],
+    name: "__SpokePool_init",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "chainId",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "l2TokenAddress", type: "bytes32" },
+      { internalType: "bytes32", name: "refundAddress", type: "bytes32" }
+    ],
+    name: "claimRelayerRefund",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "crossDomainAdmin",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "depositor", type: "bytes32" },
+      { internalType: "bytes32", name: "recipient", type: "bytes32" },
+      { internalType: "bytes32", name: "inputToken", type: "bytes32" },
+      { internalType: "bytes32", name: "outputToken", type: "bytes32" },
+      { internalType: "uint256", name: "inputAmount", type: "uint256" },
+      { internalType: "uint256", name: "outputAmount", type: "uint256" },
+      { internalType: "uint256", name: "destinationChainId", type: "uint256" },
+      { internalType: "bytes32", name: "exclusiveRelayer", type: "bytes32" },
+      { internalType: "uint32", name: "quoteTimestamp", type: "uint32" },
+      { internalType: "uint32", name: "fillDeadline", type: "uint32" },
+      { internalType: "uint32", name: "exclusivityParameter", type: "uint32" },
+      { internalType: "bytes", name: "message", type: "bytes" }
+    ],
+    name: "deposit",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "recipient", type: "address" },
+      { internalType: "address", name: "originToken", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "uint256", name: "destinationChainId", type: "uint256" },
+      { internalType: "int64", name: "relayerFeePct", type: "int64" },
+      { internalType: "uint32", name: "quoteTimestamp", type: "uint32" },
+      { internalType: "bytes", name: "message", type: "bytes" },
+      { internalType: "uint256", name: "", type: "uint256" }
+    ],
+    name: "depositDeprecated_5947912356",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "depositor", type: "address" },
+      { internalType: "address", name: "recipient", type: "address" },
+      { internalType: "address", name: "originToken", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "uint256", name: "destinationChainId", type: "uint256" },
+      { internalType: "int64", name: "relayerFeePct", type: "int64" },
+      { internalType: "uint32", name: "quoteTimestamp", type: "uint32" },
+      { internalType: "bytes", name: "message", type: "bytes" },
+      { internalType: "uint256", name: "", type: "uint256" }
+    ],
+    name: "depositFor",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "depositor", type: "bytes32" },
+      { internalType: "bytes32", name: "recipient", type: "bytes32" },
+      { internalType: "bytes32", name: "inputToken", type: "bytes32" },
+      { internalType: "bytes32", name: "outputToken", type: "bytes32" },
+      { internalType: "uint256", name: "inputAmount", type: "uint256" },
+      { internalType: "uint256", name: "outputAmount", type: "uint256" },
+      { internalType: "uint256", name: "destinationChainId", type: "uint256" },
+      { internalType: "bytes32", name: "exclusiveRelayer", type: "bytes32" },
+      { internalType: "uint32", name: "fillDeadlineOffset", type: "uint32" },
+      { internalType: "uint32", name: "exclusivityParameter", type: "uint32" },
+      { internalType: "bytes", name: "message", type: "bytes" }
+    ],
+    name: "depositNow",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "depositQuoteTimeBuffer",
+    outputs: [{ internalType: "uint32", name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "depositor", type: "address" },
+      { internalType: "address", name: "recipient", type: "address" },
+      { internalType: "address", name: "inputToken", type: "address" },
+      { internalType: "address", name: "outputToken", type: "address" },
+      { internalType: "uint256", name: "inputAmount", type: "uint256" },
+      { internalType: "uint256", name: "outputAmount", type: "uint256" },
+      { internalType: "uint256", name: "destinationChainId", type: "uint256" },
+      { internalType: "address", name: "exclusiveRelayer", type: "address" },
+      { internalType: "uint32", name: "quoteTimestamp", type: "uint32" },
+      { internalType: "uint32", name: "fillDeadline", type: "uint32" },
+      { internalType: "uint32", name: "exclusivityParameter", type: "uint32" },
+      { internalType: "bytes", name: "message", type: "bytes" }
+    ],
+    name: "depositV3",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "depositor", type: "address" },
+      { internalType: "address", name: "recipient", type: "address" },
+      { internalType: "address", name: "inputToken", type: "address" },
+      { internalType: "address", name: "outputToken", type: "address" },
+      { internalType: "uint256", name: "inputAmount", type: "uint256" },
+      { internalType: "uint256", name: "outputAmount", type: "uint256" },
+      { internalType: "uint256", name: "destinationChainId", type: "uint256" },
+      { internalType: "address", name: "exclusiveRelayer", type: "address" },
+      { internalType: "uint32", name: "fillDeadlineOffset", type: "uint32" },
+      { internalType: "uint32", name: "exclusivityParameter", type: "uint32" },
+      { internalType: "bytes", name: "message", type: "bytes" }
+    ],
+    name: "depositV3Now",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "rootBundleId", type: "uint256" }],
+    name: "emergencyDeleteRootBundle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "", type: "address" },
+      { internalType: "uint256", name: "", type: "uint256" }
+    ],
+    name: "enabledDepositRoutes",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint32", name: "rootBundleId", type: "uint32" },
+      {
+        components: [
+          { internalType: "uint256", name: "amountToReturn", type: "uint256" },
+          { internalType: "uint256", name: "chainId", type: "uint256" },
+          {
+            internalType: "uint256[]",
+            name: "refundAmounts",
+            type: "uint256[]"
+          },
+          { internalType: "uint32", name: "leafId", type: "uint32" },
+          { internalType: "address", name: "l2TokenAddress", type: "address" },
+          {
+            internalType: "address[]",
+            name: "refundAddresses",
+            type: "address[]"
+          }
+        ],
+        internalType: "struct SpokePoolInterface.RelayerRefundLeaf",
+        name: "relayerRefundLeaf",
+        type: "tuple"
+      },
+      { internalType: "bytes32[]", name: "proof", type: "bytes32[]" }
+    ],
+    name: "executeRelayerRefundLeaf",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              { internalType: "bytes32", name: "depositor", type: "bytes32" },
+              { internalType: "bytes32", name: "recipient", type: "bytes32" },
+              {
+                internalType: "bytes32",
+                name: "exclusiveRelayer",
+                type: "bytes32"
+              },
+              { internalType: "bytes32", name: "inputToken", type: "bytes32" },
+              { internalType: "bytes32", name: "outputToken", type: "bytes32" },
+              { internalType: "uint256", name: "inputAmount", type: "uint256" },
+              {
+                internalType: "uint256",
+                name: "outputAmount",
+                type: "uint256"
+              },
+              {
+                internalType: "uint256",
+                name: "originChainId",
+                type: "uint256"
+              },
+              { internalType: "uint256", name: "depositId", type: "uint256" },
+              { internalType: "uint32", name: "fillDeadline", type: "uint32" },
+              {
+                internalType: "uint32",
+                name: "exclusivityDeadline",
+                type: "uint32"
+              },
+              { internalType: "bytes", name: "message", type: "bytes" }
+            ],
+            internalType: "struct V3SpokePoolInterface.V3RelayData",
+            name: "relayData",
+            type: "tuple"
+          },
+          { internalType: "uint256", name: "chainId", type: "uint256" },
+          {
+            internalType: "uint256",
+            name: "updatedOutputAmount",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct V3SpokePoolInterface.V3SlowFill",
+        name: "slowFillLeaf",
+        type: "tuple"
+      },
+      { internalType: "uint32", name: "rootBundleId", type: "uint32" },
+      { internalType: "bytes32[]", name: "proof", type: "bytes32[]" }
+    ],
+    name: "executeSlowRelayLeaf",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "orderId", type: "bytes32" },
+      { internalType: "bytes", name: "originData", type: "bytes" },
+      { internalType: "bytes", name: "fillerData", type: "bytes" }
+    ],
+    name: "fill",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "fillDeadlineBuffer",
+    outputs: [{ internalType: "uint32", name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "bytes32", name: "depositor", type: "bytes32" },
+          { internalType: "bytes32", name: "recipient", type: "bytes32" },
+          {
+            internalType: "bytes32",
+            name: "exclusiveRelayer",
+            type: "bytes32"
+          },
+          { internalType: "bytes32", name: "inputToken", type: "bytes32" },
+          { internalType: "bytes32", name: "outputToken", type: "bytes32" },
+          { internalType: "uint256", name: "inputAmount", type: "uint256" },
+          { internalType: "uint256", name: "outputAmount", type: "uint256" },
+          { internalType: "uint256", name: "originChainId", type: "uint256" },
+          { internalType: "uint256", name: "depositId", type: "uint256" },
+          { internalType: "uint32", name: "fillDeadline", type: "uint32" },
+          {
+            internalType: "uint32",
+            name: "exclusivityDeadline",
+            type: "uint32"
+          },
+          { internalType: "bytes", name: "message", type: "bytes" }
+        ],
+        internalType: "struct V3SpokePoolInterface.V3RelayData",
+        name: "relayData",
+        type: "tuple"
+      },
+      { internalType: "uint256", name: "repaymentChainId", type: "uint256" },
+      { internalType: "bytes32", name: "repaymentAddress", type: "bytes32" }
+    ],
+    name: "fillRelay",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "bytes32", name: "depositor", type: "bytes32" },
+          { internalType: "bytes32", name: "recipient", type: "bytes32" },
+          {
+            internalType: "bytes32",
+            name: "exclusiveRelayer",
+            type: "bytes32"
+          },
+          { internalType: "bytes32", name: "inputToken", type: "bytes32" },
+          { internalType: "bytes32", name: "outputToken", type: "bytes32" },
+          { internalType: "uint256", name: "inputAmount", type: "uint256" },
+          { internalType: "uint256", name: "outputAmount", type: "uint256" },
+          { internalType: "uint256", name: "originChainId", type: "uint256" },
+          { internalType: "uint256", name: "depositId", type: "uint256" },
+          { internalType: "uint32", name: "fillDeadline", type: "uint32" },
+          {
+            internalType: "uint32",
+            name: "exclusivityDeadline",
+            type: "uint32"
+          },
+          { internalType: "bytes", name: "message", type: "bytes" }
+        ],
+        internalType: "struct V3SpokePoolInterface.V3RelayData",
+        name: "relayData",
+        type: "tuple"
+      },
+      { internalType: "uint256", name: "repaymentChainId", type: "uint256" },
+      { internalType: "bytes32", name: "repaymentAddress", type: "bytes32" },
+      { internalType: "uint256", name: "updatedOutputAmount", type: "uint256" },
+      { internalType: "bytes32", name: "updatedRecipient", type: "bytes32" },
+      { internalType: "bytes", name: "updatedMessage", type: "bytes" },
+      { internalType: "bytes", name: "depositorSignature", type: "bytes" }
+    ],
+    name: "fillRelayWithUpdatedDeposit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    name: "fillStatuses",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "depositor", type: "address" },
+          { internalType: "address", name: "recipient", type: "address" },
+          {
+            internalType: "address",
+            name: "exclusiveRelayer",
+            type: "address"
+          },
+          { internalType: "address", name: "inputToken", type: "address" },
+          { internalType: "address", name: "outputToken", type: "address" },
+          { internalType: "uint256", name: "inputAmount", type: "uint256" },
+          { internalType: "uint256", name: "outputAmount", type: "uint256" },
+          { internalType: "uint256", name: "originChainId", type: "uint256" },
+          { internalType: "uint32", name: "depositId", type: "uint32" },
+          { internalType: "uint32", name: "fillDeadline", type: "uint32" },
+          {
+            internalType: "uint32",
+            name: "exclusivityDeadline",
+            type: "uint32"
+          },
+          { internalType: "bytes", name: "message", type: "bytes" }
+        ],
+        internalType: "struct V3SpokePoolInterface.V3RelayDataLegacy",
+        name: "relayData",
+        type: "tuple"
+      },
+      { internalType: "uint256", name: "repaymentChainId", type: "uint256" }
+    ],
+    name: "fillV3Relay",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getCurrentTime",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "l2TokenAddress", type: "address" },
+      { internalType: "address", name: "refundAddress", type: "address" }
+    ],
+    name: "getRelayerRefund",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "msgSender", type: "address" },
+      { internalType: "bytes32", name: "depositor", type: "bytes32" },
+      { internalType: "uint256", name: "depositNonce", type: "uint256" }
+    ],
+    name: "getUnsafeDepositId",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "bytes32", name: "depositor", type: "bytes32" },
+          { internalType: "bytes32", name: "recipient", type: "bytes32" },
+          {
+            internalType: "bytes32",
+            name: "exclusiveRelayer",
+            type: "bytes32"
+          },
+          { internalType: "bytes32", name: "inputToken", type: "bytes32" },
+          { internalType: "bytes32", name: "outputToken", type: "bytes32" },
+          { internalType: "uint256", name: "inputAmount", type: "uint256" },
+          { internalType: "uint256", name: "outputAmount", type: "uint256" },
+          { internalType: "uint256", name: "originChainId", type: "uint256" },
+          { internalType: "uint256", name: "depositId", type: "uint256" },
+          { internalType: "uint32", name: "fillDeadline", type: "uint32" },
+          {
+            internalType: "uint32",
+            name: "exclusivityDeadline",
+            type: "uint32"
+          },
+          { internalType: "bytes", name: "message", type: "bytes" }
+        ],
+        internalType: "struct V3SpokePoolInterface.V3RelayData",
+        name: "relayData",
+        type: "tuple"
+      }
+    ],
+    name: "getV3RelayHash",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint32", name: "_initialDepositId", type: "uint32" },
+      {
+        internalType: "address",
+        name: "_withdrawalRecipient",
+        type: "address"
+      }
+    ],
+    name: "initialize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes[]", name: "data", type: "bytes[]" }],
+    name: "multicall",
+    outputs: [{ internalType: "bytes[]", name: "results", type: "bytes[]" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "numberOfDeposits",
+    outputs: [{ internalType: "uint32", name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bool", name: "pause", type: "bool" }],
+    name: "pauseDeposits",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bool", name: "pause", type: "bool" }],
+    name: "pauseFills",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pausedDeposits",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pausedFills",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "proxiableUUID",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "relayerRefundRoot", type: "bytes32" },
+      { internalType: "bytes32", name: "slowRelayRoot", type: "bytes32" }
+    ],
+    name: "relayRootBundle",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "", type: "address" },
+      { internalType: "address", name: "", type: "address" }
+    ],
+    name: "relayerRefund",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "bytes32", name: "depositor", type: "bytes32" },
+          { internalType: "bytes32", name: "recipient", type: "bytes32" },
+          {
+            internalType: "bytes32",
+            name: "exclusiveRelayer",
+            type: "bytes32"
+          },
+          { internalType: "bytes32", name: "inputToken", type: "bytes32" },
+          { internalType: "bytes32", name: "outputToken", type: "bytes32" },
+          { internalType: "uint256", name: "inputAmount", type: "uint256" },
+          { internalType: "uint256", name: "outputAmount", type: "uint256" },
+          { internalType: "uint256", name: "originChainId", type: "uint256" },
+          { internalType: "uint256", name: "depositId", type: "uint256" },
+          { internalType: "uint32", name: "fillDeadline", type: "uint32" },
+          {
+            internalType: "uint32",
+            name: "exclusivityDeadline",
+            type: "uint32"
+          },
+          { internalType: "bytes", name: "message", type: "bytes" }
+        ],
+        internalType: "struct V3SpokePoolInterface.V3RelayData",
+        name: "relayData",
+        type: "tuple"
+      }
+    ],
+    name: "requestSlowFill",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    name: "rootBundles",
+    outputs: [
+      { internalType: "bytes32", name: "slowRelayRoot", type: "bytes32" },
+      { internalType: "bytes32", name: "relayerRefundRoot", type: "bytes32" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "newCrossDomainAdmin", type: "address" }],
+    name: "setCrossDomainAdmin",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "originToken", type: "address" },
+      { internalType: "uint256", name: "destinationChainId", type: "uint256" },
+      { internalType: "bool", name: "enabled", type: "bool" }
+    ],
+    name: "setEnableRoute",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newWithdrawalRecipient",
+        type: "address"
+      }
+    ],
+    name: "setWithdrawalRecipient",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "depositor", type: "bytes32" },
+      { internalType: "uint256", name: "depositId", type: "uint256" },
+      { internalType: "uint256", name: "updatedOutputAmount", type: "uint256" },
+      { internalType: "bytes32", name: "updatedRecipient", type: "bytes32" },
+      { internalType: "bytes", name: "updatedMessage", type: "bytes" },
+      { internalType: "bytes", name: "depositorSignature", type: "bytes" }
+    ],
+    name: "speedUpDeposit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "depositor", type: "address" },
+      { internalType: "uint256", name: "depositId", type: "uint256" },
+      { internalType: "uint256", name: "updatedOutputAmount", type: "uint256" },
+      { internalType: "address", name: "updatedRecipient", type: "address" },
+      { internalType: "bytes", name: "updatedMessage", type: "bytes" },
+      { internalType: "bytes", name: "depositorSignature", type: "bytes" }
+    ],
+    name: "speedUpV3Deposit",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes[]", name: "data", type: "bytes[]" }],
+    name: "tryMulticall",
+    outputs: [
+      {
+        components: [
+          { internalType: "bool", name: "success", type: "bool" },
+          { internalType: "bytes", name: "returnData", type: "bytes" }
+        ],
+        internalType: "struct MultiCallerUpgradeable.Result[]",
+        name: "results",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "depositor", type: "bytes32" },
+      { internalType: "bytes32", name: "recipient", type: "bytes32" },
+      { internalType: "bytes32", name: "inputToken", type: "bytes32" },
+      { internalType: "bytes32", name: "outputToken", type: "bytes32" },
+      { internalType: "uint256", name: "inputAmount", type: "uint256" },
+      { internalType: "uint256", name: "outputAmount", type: "uint256" },
+      { internalType: "uint256", name: "destinationChainId", type: "uint256" },
+      { internalType: "bytes32", name: "exclusiveRelayer", type: "bytes32" },
+      { internalType: "uint256", name: "depositNonce", type: "uint256" },
+      { internalType: "uint32", name: "quoteTimestamp", type: "uint32" },
+      { internalType: "uint32", name: "fillDeadline", type: "uint32" },
+      { internalType: "uint32", name: "exclusivityParameter", type: "uint32" },
+      { internalType: "bytes", name: "message", type: "bytes" }
+    ],
+    name: "unsafeDeposit",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "newImplementation", type: "address" }],
+    name: "upgradeTo",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "newImplementation", type: "address" },
+      { internalType: "bytes", name: "data", type: "bytes" }
+    ],
+    name: "upgradeToAndCall",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "withdrawalRecipient",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "wrappedNativeToken",
+    outputs: [{ internalType: "contract WETH9Interface", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  { stateMutability: "payable", type: "receive" }
+];
+
+// src/providers/across/createAcrossDepositCall.ts
+import { getGlobalAdapter as getGlobalAdapter3 } 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 = getGlobalAdapter3();
+  const spokePoolAddress = ACROSS_SPOOK_CONTRACT_ADDRESSES[sellTokenChainId];
+  if (!spokePoolAddress) {
+    throw new Error("Spoke pool address not found for chain: " + sellTokenChainId);
+  }
+  return createWeirollContract(
+    adapter.getContract(spokePoolAddress, ACROSS_SPOKE_POOL_ABI),
+    WeirollCommandFlags.CALL
+  );
+}
+function getMathContract(sellTokenChainId) {
+  const adapter = getGlobalAdapter3();
+  const mathContractAddress = ACROSS_MATH_CONTRACT_ADDRESSES[sellTokenChainId];
+  if (!mathContractAddress) {
+    throw new Error("Math contract address not found for chain: " + sellTokenChainId);
+  }
+  return createWeirollContract(
+    adapter.getContract(mathContractAddress, ACROSS_MATH_ABI),
+    WeirollCommandFlags.CALL
+  );
+}
+function getBalanceOfSellTokenContract(sellTokenAddress) {
+  const adapter = getGlobalAdapter3();
+  return createWeirollContract(
+    adapter.getContract(sellTokenAddress, ERC20_BALANCE_OF_ABI),
+    WeirollCommandFlags.STATICCALL
+  );
+}
+function getApproveSellTokenContract(sellTokenAddress) {
+  const adapter = getGlobalAdapter3();
+  return createWeirollContract(adapter.getContract(sellTokenAddress, ERC20_APPROVE_OF_ABI), WeirollCommandFlags.CALL);
+}
+function createAcrossDepositCall(params) {
+  const { request, quote, cowShedSdk } = params;
+  const { sellTokenChainId, sellTokenAddress, buyTokenChainId, buyTokenAddress, account, receiver } = request;
+  const spokePoolContract = getSpookPoolContract(sellTokenChainId);
+  const mathContract = getMathContract(sellTokenChainId);
+  const balanceOfSellTokenContract = getBalanceOfSellTokenContract(sellTokenAddress);
+  const approveSellTokenContract = getApproveSellTokenContract(sellTokenAddress);
+  const cowShedAccount = cowShedSdk.getCowShedAccount(sellTokenChainId, account);
+  const { suggestedFees } = quote;
+  const depositCall = createWeirollDelegateCall((planner) => {
+    const sourceAmountIncludingSurplus = planner.add(balanceOfSellTokenContract.balanceOf(cowShedAccount));
+    const relayFeePercentage = BigInt(suggestedFees.totalRelayFee.pct);
+    const outputAmountIncludingSurplus = planner.add(
+      mathContract.multiplyAndSubtract(sourceAmountIncludingSurplus, relayFeePercentage)
+    );
+    planner.add(approveSellTokenContract.approve(spokePoolContract.address, sourceAmountIncludingSurplus));
+    const quoteTimestamp = BigInt(suggestedFees.timestamp);
+    const fillDeadline = suggestedFees.fillDeadline;
+    const exclusivityDeadline = suggestedFees.exclusivityDeadline;
+    const exclusiveRelayer = suggestedFees.exclusiveRelayer;
+    const message = "0x";
+    planner.add(
+      spokePoolContract.depositV3(
+        cowShedAccount,
+        receiver || account,
+        sellTokenAddress,
+        buyTokenAddress,
+        sourceAmountIncludingSurplus,
+        outputAmountIncludingSurplus,
+        buyTokenChainId,
+        exclusiveRelayer,
+        quoteTimestamp,
+        fillDeadline,
+        exclusivityDeadline,
+        message
+      )
+    );
+  });
+  return depositCall;
+}
+
+// src/providers/across/AcrossBridgeProvider.ts
+import { ContractsOrderKind as OrderKind4 } from "@cowprotocol/sdk-contracts-ts";
+var HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX}/across`;
+var ACROSS_SUPPORTED_NETWORKS = [mainnet2, polygon, arbitrumOne, base, optimism2];
+var SLIPPAGE_TOLERANCE_BPS = 0;
+var AcrossBridgeProvider = class {
+  constructor(options = {}, adapter) {
+    this.options = options;
+    if (adapter) {
+      setGlobalAdapter2(adapter);
+    }
+    this.api = new AcrossApi(options.apiOptions);
+    this.cowShedSdk = new CowShedSdk(adapter, options.cowShedOptions?.factoryOptions);
+  }
+  api;
+  cowShedSdk;
+  info = {
+    name: "Across",
+    logoUrl: `${RAW_PROVIDERS_FILES_PATH}/across/across-logo.png`
+  };
+  async getNetworks() {
+    return ACROSS_SUPPORTED_NETWORKS;
+  }
+  async getBuyTokens(targetChainId) {
+    if (!this.options.getTokenInfos) {
+      throw new Error("'getTokenInfos' parameter is required for AcrossBridgeProvider constructor");
+    }
+    const chainConfig = ACROSS_TOKEN_MAPPING[targetChainId];
+    if (!chainConfig) {
+      return [];
+    }
+    const tokenAddresses = Object.values(chainConfig.tokens).filter((address) => Boolean(address));
+    return this.options.getTokenInfos(targetChainId, tokenAddresses);
+  }
+  async getIntermediateTokens(request) {
+    if (request.kind !== OrderKind4.SELL) {
+      throw new Error("Only SELL is supported for now");
+    }
+    const { sellTokenChainId, buyTokenChainId, buyTokenAddress } = request;
+    const chainConfigs = getChainConfigs(sellTokenChainId, buyTokenChainId);
+    if (!chainConfigs)
+      return [];
+    const { sourceChainConfig, targetChainConfig } = chainConfigs;
+    const targetTokenSymbol = getTokenSymbol(buyTokenAddress, targetChainConfig);
+    if (!targetTokenSymbol)
+      return [];
+    const intermediateToken = getTokenAddress(targetTokenSymbol, sourceChainConfig);
+    return intermediateToken ? [intermediateToken] : [];
+  }
+  async getQuote(request) {
+    const { sellTokenAddress, sellTokenChainId, buyTokenChainId, amount, receiver } = request;
+    const suggestedFees = await this.api.getSuggestedFees({
+      token: sellTokenAddress,
+      // inputToken: sellTokenAddress,
+      // outputToken: buyTokenAddress,
+      originChainId: sellTokenChainId,
+      destinationChainId: buyTokenChainId,
+      amount,
+      recipient: receiver ?? void 0
+    });
+    return toBridgeQuoteResult(request, SLIPPAGE_TOLERANCE_BPS, suggestedFees);
+  }
+  async getUnsignedBridgeCall(request, quote) {
+    return createAcrossDepositCall({
+      request,
+      quote,
+      cowShedSdk: this.cowShedSdk
+    });
+  }
+  getGasLimitEstimationForHook(_request) {
+    return DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION;
+  }
+  async getSignedHook(chainId, unsignedCall, defaultGasLimit, signer) {
+    const { signedMulticall, cowShedAccount, gasLimit } = await this.cowShedSdk.signCalls({
+      calls: [
+        {
+          target: unsignedCall.to,
+          value: unsignedCall.value,
+          callData: unsignedCall.data,
+          allowFailure: false,
+          isDelegateCall: true
+        }
+      ],
+      chainId,
+      signer,
+      defaultGasLimit
+    });
+    const { to, data } = signedMulticall;
+    return {
+      postHook: {
+        target: to,
+        callData: data,
+        gasLimit: gasLimit.toString(),
+        dappId: HOOK_DAPP_ID
+        // TODO: I think we should have some additional parameter to type the hook (using dappId for now)
+      },
+      recipient: cowShedAccount
+    };
+  }
+  async decodeBridgeHook(_hook) {
+    throw new Error("Not implemented");
+  }
+  async getBridgingId(_orderUid, _settlementTx, _logIndex) {
+    throw new Error("Not implemented");
+  }
+  getExplorerUrl(bridgingId) {
+    return `https://app.across.to/transactions/${bridgingId}`;
+  }
+  async getStatus(_bridgingId) {
+    throw new Error("Not implemented");
+  }
+  async getCancelBridgingTx(_bridgingId) {
+    throw new Error("Not implemented");
+  }
+  async getRefundBridgingTx(_bridgingId) {
+    throw new Error("Not implemented");
+  }
+};
+export {
+  AcrossBridgeProvider,
+  BridgeProviderQuoteError,
+  BridgeStatus,
+  BridgingSdk,
+  MockBridgeProvider,
+  areHooksEqual,
+  assertIsBridgeQuoteAndPost,
+  assertIsQuoteAndPost,
+  getHookMockForCostEstimation,
+  getPostHooks,
+  isAppDoc,
+  isBridgeQuoteAndPost,
+  isQuoteAndPost
+};