@cowprotocol/sdk-bridging 0.6.1 → 0.8.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -33,6 +43,7 @@ __export(src_exports, {
   DEFAULT_EXTRA_GAS_PROXY_CREATION: () => DEFAULT_EXTRA_GAS_PROXY_CREATION,
   DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION: () => DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION,
   HOOK_DAPP_BRIDGE_PROVIDER_PREFIX: () => HOOK_DAPP_BRIDGE_PROVIDER_PREFIX,
+  NearIntentsBridgeProvider: () => NearIntentsBridgeProvider,
   RAW_PROVIDERS_FILES_PATH: () => RAW_PROVIDERS_FILES_PATH,
   assertIsBridgeQuoteAndPost: () => assertIsBridgeQuoteAndPost,
   assertIsQuoteAndPost: () => assertIsQuoteAndPost,
@@ -66,6 +77,7 @@ var BridgeQuoteErrors = /* @__PURE__ */ ((BridgeQuoteErrors2) => {
   BridgeQuoteErrors2["QUOTE_ERROR"] = "QUOTE_ERROR";
   BridgeQuoteErrors2["NO_ROUTES"] = "NO_ROUTES";
   BridgeQuoteErrors2["INVALID_BRIDGE"] = "INVALID_BRIDGE";
+  BridgeQuoteErrors2["QUOTE_DOES_NOT_MATCH_DEPOSIT_ADDRESS"] = "QUOTE_DOES_NOT_MATCH_DEPOSIT_ADDRESS";
   return BridgeQuoteErrors2;
 })(BridgeQuoteErrors || {});
 var BridgeProviderQuoteError = class extends Error {
@@ -111,7 +123,7 @@ function getPostHooks(fullAppData) {
   if (!fullAppData) {
     return [];
   }
-  const appData = JSON.parse(fullAppData);
+  const appData = typeof fullAppData === "string" ? JSON.parse(fullAppData) : fullAppData;
   if (!isAppDoc(appData)) {
     return [];
   }
@@ -141,14 +153,18 @@ var HOOK_DAPP_BRIDGE_PROVIDER_PREFIX = "cow-sdk://bridging/providers";
 
 // src/BridgingSdk/findBridgeProviderFromHook.ts
 function findBridgeProviderFromHook(fullAppData, providers) {
-  const postHooks = getPostHooks(fullAppData);
-  const bridgingHook = postHooks.find((hook) => {
-    return hook.dappId?.startsWith(HOOK_DAPP_BRIDGE_PROVIDER_PREFIX);
-  });
-  if (!bridgingHook) {
-    return void 0;
+  const appDataObj = JSON.parse(fullAppData);
+  let bridgeProviderDappId = appDataObj?.metadata?.bridging?.providerId;
+  if (!bridgeProviderDappId) {
+    const postHooks = getPostHooks(appDataObj);
+    const bridgingHook = postHooks.find((hook) => {
+      return hook.dappId?.startsWith(HOOK_DAPP_BRIDGE_PROVIDER_PREFIX);
+    });
+    if (!bridgingHook) {
+      return void 0;
+    }
+    bridgeProviderDappId = bridgingHook.dappId;
   }
-  const bridgeProviderDappId = bridgingHook.dappId;
   return providers.find((provider) => provider.info.dappId === bridgeProviderDappId);
 }
 
@@ -172,7 +188,7 @@ async function getCrossChainOrder(params) {
         `No tx hash found for order ${orderId} . First trade, with log index ${firstTrade?.logIndex}`
       );
     }
-    const { params: bridgingParams, status: statusResult } = await provider.getBridgingParams(chainId, orderId, tradeTxHash) || {};
+    const { params: bridgingParams, status: statusResult } = await provider.getBridgingParams(chainId, order, tradeTxHash) || {};
     if (!bridgingParams || !statusResult) {
       throw new BridgeOrderParsingError(`Bridging params cannot be derived from transaction: ${tradeTxHash}`);
     }
@@ -326,6 +342,7 @@ async function getIntermediateSwapResult({
       metadata: {
         hooks,
         bridging: {
+          providerId: provider.info.dappId,
           destinationChainId: buyTokenChainId.toString(),
           destinationTokenAddress: buyTokenAddress
         }
@@ -367,7 +384,9 @@ async function getIntermediateTokens(params) {
     intermediateTokens = cached;
   } else {
     intermediateTokens = await provider.getIntermediateTokens(quoteBridgeRequest);
-    intermediateTokensCache?.set(cacheKey, intermediateTokens);
+    if (intermediateTokens?.length) {
+      intermediateTokensCache?.set(cacheKey, intermediateTokens);
+    }
   }
   if (intermediateTokens.length === 0) {
     throw new BridgeProviderQuoteError("NO_INTERMEDIATE_TOKENS" /* NO_INTERMEDIATE_TOKENS */);
@@ -422,13 +441,22 @@ async function getQuoteWithBridge(provider, params) {
   throw new Error("Provider type is unknown: " + provider.type);
 }
 function createPostSwapOrderFromQuote(params) {
-  const { getBridgeProviderQuote, signer, sellTokenAddress, orderBookApi } = params;
+  const { provider, getBridgeProviderQuote, signer, sellTokenAddress, orderBookApi, initialSwapResult } = params;
   return async function postSwapOrderFromQuote(advancedSettings, signingStepManager) {
     await signingStepManager?.beforeBridgingSign?.();
-    const { swapResult } = await getBridgeProviderQuote(signer, advancedSettings).catch((error) => {
-      signingStepManager?.onBridgingSignError?.();
-      throw error;
-    });
+    const skipQuoteRefetch = isReceiverAccountBridgeProvider(provider);
+    const appDataOverride = advancedSettings?.appData;
+    const appDataInfo = appDataOverride && skipQuoteRefetch ? await (0, import_sdk_trading.mergeAppDataDoc)(initialSwapResult.appDataInfo.doc, appDataOverride) : initialSwapResult.appDataInfo;
+    const swapResult = skipQuoteRefetch ? {
+      ...initialSwapResult,
+      appDataInfo
+    } : (
+      // Sign the hooks with the real signer
+      (await getBridgeProviderQuote(signer, advancedSettings).catch((error) => {
+        signingStepManager?.onBridgingSignError?.();
+        throw error;
+      })).swapResult
+    );
     await signingStepManager?.afterBridgingSign?.();
     const quoteResults = {
       result: {
@@ -479,6 +507,11 @@ async function getQuoteWithReceiverAccountBridge(provider, params) {
     });
     (0, import_sdk_common4.log)(`Bridge receiver override: ${bridgeReceiverOverride}`);
     swapResult.tradeParameters.receiver = bridgeReceiverOverride;
+    swapResult.appDataInfo = await (0, import_sdk_trading.mergeAppDataDoc)(swapResult.appDataInfo.doc, {
+      metadata: {
+        bridging: overrideAppDataWithBridgingQuoteDetails(swapResult.appDataInfo.doc.metadata.bridging, bridgeResult)
+      }
+    });
     return {
       bridgeResult,
       swapResult: {
@@ -495,10 +528,12 @@ async function getQuoteWithReceiverAccountBridge(provider, params) {
     swap: result.swapResult,
     bridge: result.bridgeResult,
     postSwapOrderFromQuote: createPostSwapOrderFromQuote({
+      provider,
       getBridgeProviderQuote,
       signer,
       sellTokenAddress: swapAndBridgeRequest.sellTokenAddress,
-      orderBookApi
+      orderBookApi,
+      initialSwapResult: result.swapResult
     })
   };
 }
@@ -577,7 +612,9 @@ async function getQuoteWithHookBridge(provider, params) {
       getBridgeProviderQuote: (signer2, advancedSettings) => getBridgeProviderQuote(signer2, hookEstimatedGasLimit, advancedSettings),
       signer,
       sellTokenAddress: swapAndBridgeRequest.sellTokenAddress,
-      orderBookApi
+      orderBookApi,
+      provider,
+      initialSwapResult: result.swapResult
     })
   };
 }
@@ -590,6 +627,8 @@ async function getAccountBridgeResult(provider, context) {
   const bridgingQuote = await provider.getQuote(bridgeRequest);
   const bridgeReceiverOverride = await provider.getBridgeReceiverOverride(bridgeRequest, bridgingQuote);
   const bridgeResult = {
+    id: bridgingQuote.id,
+    signature: bridgingQuote.signature,
     providerInfo: provider.info,
     tradeParameters: bridgeRequest,
     // Just the bridge (not the swap & bridge)
@@ -621,6 +660,7 @@ async function getHookBridgeResult(provider, context) {
   });
   const appDataInfo = await (0, import_sdk_trading.mergeAppDataDoc)(swapAppData.doc, {
     metadata: {
+      bridging: overrideAppDataWithBridgingQuoteDetails(swapResult.appDataInfo.doc.metadata.bridging, bridgingQuote),
       hooks: {
         pre: swapResultHooks?.pre,
         post: [...postHooks, ...[bridgeHook.postHook]]
@@ -644,6 +684,15 @@ async function getHookBridgeResult(provider, context) {
   };
   return { bridgeResult, bridgeHook, appDataInfo };
 }
+function overrideAppDataWithBridgingQuoteDetails(bridgingMetaData, quote) {
+  if (!bridgingMetaData)
+    return bridgingMetaData;
+  return {
+    ...bridgingMetaData,
+    ...quote.id ? { quoteId: quote.id } : void 0,
+    ...quote.signature ? { quoteSignature: quote.signature } : void 0
+  };
+}
 
 // src/BridgingSdk/strategies/QuoteStrategy.ts
 var QuoteStrategy = class {
@@ -664,10 +713,9 @@ var SingleQuoteStrategy = class extends BaseSingleQuoteStrategy {
   constructor(intermediateTokensCache) {
     super(intermediateTokensCache);
   }
-  async execute(request, config) {
+  async execute(request, tradingSdk, providers) {
     const { quoteBridgeRequest, advancedSettings } = request;
     const { sellTokenChainId, buyTokenChainId } = quoteBridgeRequest;
-    const { tradingSdk, providers } = config;
     if (sellTokenChainId !== buyTokenChainId) {
       const provider = providers[0];
       if (!provider) {
@@ -703,7 +751,7 @@ function validateCrossChainRequest(sellTokenChainId, buyTokenChainId) {
     );
   }
 }
-function createBridgeQuoteTimeoutPromise(timeoutMs, prefix) {
+function createBridgeRequestTimeoutPromise(timeoutMs, prefix) {
   return new Promise((_, reject) => {
     setTimeout(() => {
       reject(new BridgeProviderError(`${prefix} timeout after ${timeoutMs}ms`, {}));
@@ -732,11 +780,11 @@ function fillTimeoutResults(results, providersToQuery) {
     }
   }
 }
-async function executeProviderQuotes(promises, timeout, config) {
+async function executeProviderQuotes(promises, timeout, providers) {
   try {
     await Promise.race([
       Promise.allSettled(promises),
-      createBridgeQuoteTimeoutPromise(timeout, `Multi-quote with ${config.providers.length}`)
+      createBridgeRequestTimeoutPromise(timeout, `Multi-quote with ${providers.length}`)
     ]);
   } catch {
     console.warn("getMultiQuotes timeout occurred, returning partial results");
@@ -787,11 +835,11 @@ var MultiQuoteStrategy = class extends BaseMultiQuoteStrategy {
   constructor(intermediateTokensCache) {
     super(intermediateTokensCache);
   }
-  async execute(request, config) {
+  async execute(request, tradingSdk, providers) {
     const { quoteBridgeRequest, providerDappIds, advancedSettings, options } = request;
     const { sellTokenChainId, buyTokenChainId } = quoteBridgeRequest;
     validateCrossChainRequest(sellTokenChainId, buyTokenChainId);
-    const providersToQuery = resolveProvidersToQuery(providerDappIds, config.providers);
+    const providersToQuery = resolveProvidersToQuery(providerDappIds, providers);
     const {
       onQuoteResult,
       totalTimeout = DEFAULT_TOTAL_TIMEOUT_MS,
@@ -813,10 +861,10 @@ var MultiQuoteStrategy = class extends BaseMultiQuoteStrategy {
         results,
         index: i
       };
-      const promise = this.createProviderQuotePromise(context, config);
+      const promise = this.createProviderQuotePromise(context, tradingSdk);
       promises.push(promise);
     }
-    await executeProviderQuotes(promises, totalTimeout, config);
+    await executeProviderQuotes(promises, totalTimeout, providers);
     fillTimeoutResults(results, providersToQuery);
     results.sort((a, b) => {
       if (isBetterQuote(a, b))
@@ -827,14 +875,14 @@ var MultiQuoteStrategy = class extends BaseMultiQuoteStrategy {
     });
     return results;
   }
-  createProviderQuotePromise(context, config) {
+  createProviderQuotePromise(context, tradingSdk) {
     const { provider, quoteBridgeRequest, advancedSettings, providerTimeout, onQuoteResult, results, index } = context;
     return (async () => {
       try {
         const baseParams = {
           swapAndBridgeRequest: quoteBridgeRequest,
           advancedSettings,
-          tradingSdk: config.tradingSdk,
+          tradingSdk,
           quoteSigner: advancedSettings?.quoteSigner
         };
         const request = this.intermediateTokensCache ? {
@@ -843,7 +891,7 @@ var MultiQuoteStrategy = class extends BaseMultiQuoteStrategy {
         } : baseParams;
         const quote = await Promise.race([
           getQuoteWithBridge(provider, request),
-          createBridgeQuoteTimeoutPromise(providerTimeout, `Provider ${provider.info.dappId}`)
+          createBridgeRequestTimeoutPromise(providerTimeout, `Provider ${provider.info.dappId}`)
         ]);
         const result = {
           providerDappId: provider.info.dappId,
@@ -873,11 +921,11 @@ var BestQuoteStrategy = class extends BaseBestQuoteStrategy {
   constructor(intermediateTokensCache) {
     super(intermediateTokensCache);
   }
-  async execute(request, config) {
+  async execute(request, tradingSdk, providers) {
     const { quoteBridgeRequest, providerDappIds, advancedSettings, options } = request;
     const { sellTokenChainId, buyTokenChainId } = quoteBridgeRequest;
     validateCrossChainRequest(sellTokenChainId, buyTokenChainId);
-    const providersToQuery = resolveProvidersToQuery(providerDappIds, config.providers);
+    const providersToQuery = resolveProvidersToQuery(providerDappIds, providers);
     const {
       onQuoteResult,
       totalTimeout = DEFAULT_TOTAL_TIMEOUT_MS2,
@@ -896,20 +944,20 @@ var BestQuoteStrategy = class extends BaseBestQuoteStrategy {
         bestResult,
         firstError
       };
-      const promise = this.createBestQuoteProviderPromise(context, config);
+      const promise = this.createBestQuoteProviderPromise(context, tradingSdk);
       promises.push(promise);
     }
-    await executeProviderQuotes(promises, totalTimeout, config);
+    await executeProviderQuotes(promises, totalTimeout, providers);
     return bestResult.current || firstError.current;
   }
-  createBestQuoteProviderPromise(context, config) {
+  createBestQuoteProviderPromise(context, tradingSdk) {
     const { provider, quoteBridgeRequest, advancedSettings, providerTimeout, onQuoteResult, bestResult, firstError } = context;
     return (async () => {
       try {
         const baseParams = {
           swapAndBridgeRequest: quoteBridgeRequest,
           advancedSettings,
-          tradingSdk: config.tradingSdk,
+          tradingSdk,
           provider,
           quoteSigner: advancedSettings?.quoteSigner
         };
@@ -919,7 +967,7 @@ var BestQuoteStrategy = class extends BaseBestQuoteStrategy {
         } : baseParams;
         const quote = await Promise.race([
           getQuoteWithBridge(provider, request),
-          createBridgeQuoteTimeoutPromise(providerTimeout, `Provider ${provider.info.dappId}`)
+          createBridgeRequestTimeoutPromise(providerTimeout, `Provider ${provider.info.dappId}`)
         ]);
         const result = {
           providerDappId: provider.info.dappId,
@@ -957,10 +1005,11 @@ function createStrategies(intermediateTokensCache) {
 var DEFAULT_CACHE_CONFIG = {
   enabled: true,
   intermediateTokensTtl: 5 * 60 * 1e3,
-  // 5 minutes
+  // 2 minutes
   buyTokensTtl: 2 * 60 * 1e3
   // 2 minutes
 };
+var DEFAULT_MULTI_PROVIDER_REQUEST_TIMEOUT = 10 * 1e3;
 var BridgingSdk = class {
   constructor(options, adapter) {
     this.options = options;
@@ -1007,18 +1056,18 @@ var BridgingSdk = class {
   singleQuoteStrategy;
   multiQuoteStrategy;
   bestQuoteStrategy;
-  get provider() {
-    const { providers } = this.config;
-    if (!providers[0]) {
-      throw new BridgeProviderError("No provider found", { config: this.config });
-    }
-    return providers[0];
+  availableProvidersIds = [];
+  setAvailableProviders(ids) {
+    this.availableProvidersIds = ids;
   }
   /**
    * Get the providers for the bridging.
    */
-  getProviders() {
-    return this.config.providers;
+  getAvailableProviders() {
+    if (this.availableProvidersIds.length === 0) {
+      return this.config.providers;
+    }
+    return this.config.providers.filter((provider) => this.availableProvidersIds.includes(provider.info.dappId));
   }
   /**
    * Get the available sources networks for the bridging.
@@ -1030,7 +1079,21 @@ var BridgingSdk = class {
    * Get the available target networks for the bridging.
    */
   async getTargetNetworks() {
-    return this.provider.getNetworks();
+    const providers = this.getAvailableProviders();
+    const results = await Promise.race([
+      Promise.allSettled(providers.map((provider) => provider.getNetworks())),
+      createBridgeRequestTimeoutPromise(
+        DEFAULT_MULTI_PROVIDER_REQUEST_TIMEOUT,
+        `Multi-provider getTargetNetworks with ${providers.length}`
+      )
+    ]);
+    return results.reduce((acc, result) => {
+      if (result.status === "fulfilled") {
+        const networksToAdd = (result.value || []).filter((network) => !acc.includes(network));
+        return acc.concat(networksToAdd);
+      }
+      return acc;
+    }, []);
   }
   /**
      * Get the available buy tokens for buying in a specific target chain
@@ -1038,22 +1101,32 @@ var BridgingSdk = class {
      * @param params
      */
   async getBuyTokens(params) {
-    const providerId = this.provider.info.dappId;
-    const cacheKey = getCacheKey({
-      id: providerId,
-      buyChainId: params.buyChainId.toString(),
-      sellChainId: params.sellChainId?.toString(),
-      tokenAddress: params.sellTokenAddress
-    });
-    const cached = this.cacheConfig.enabled && this.buyTokensCache.get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-    const result = await this.provider.getBuyTokens(params);
-    if (this.cacheConfig.enabled) {
-      this.buyTokensCache.set(cacheKey, result);
-    }
-    return result;
+    const providers = this.getAvailableProviders();
+    const results = await Promise.race([
+      Promise.allSettled(providers.map((provider) => this.getBuyTokensFromProvider(provider, params))),
+      createBridgeRequestTimeoutPromise(
+        DEFAULT_MULTI_PROVIDER_REQUEST_TIMEOUT,
+        `Multi-provider getBuyTokens with ${providers.length}`
+      )
+    ]);
+    const isRouteAvailable = results.reduce((isRouteAvailable2, result) => {
+      if (result.status === "fulfilled" && result.value.isRouteAvailable) {
+        return true;
+      }
+      return isRouteAvailable2;
+    }, false);
+    const tokens = results.reduce((tokens2, result) => {
+      if (result.status === "fulfilled" && result.value.tokens) {
+        result.value.tokens.forEach((token) => {
+          const addressLower = token.address.toLowerCase();
+          if (!tokens2.get(addressLower)) {
+            tokens2.set(addressLower, token);
+          }
+        });
+      }
+      return tokens2;
+    }, /* @__PURE__ */ new Map());
+    return { isRouteAvailable, tokens: [...tokens.values()] };
   }
   /**
    * Get quote details, including a callback function to post the order on-chain.
@@ -1076,7 +1149,8 @@ var BridgingSdk = class {
         quoteBridgeRequest,
         advancedSettings
       },
-      this.config
+      this.config.tradingSdk,
+      this.getAvailableProviders()
     );
   }
   /**
@@ -1095,7 +1169,7 @@ var BridgingSdk = class {
    * ```
    */
   async getMultiQuotes(request) {
-    return this.multiQuoteStrategy.execute(request, this.config);
+    return this.multiQuoteStrategy.execute(request, this.config.tradingSdk, this.getAvailableProviders());
   }
   /**
    * Get the best quote from multiple bridge providers with progressive updates.
@@ -1113,7 +1187,7 @@ var BridgingSdk = class {
    * @throws Error if the request is for a single-chain swap (sellTokenChainId === buyTokenChainId)
    */
   async getBestQuote(request) {
-    return this.bestQuoteStrategy.execute(request, this.config);
+    return this.bestQuoteStrategy.execute(request, this.config.tradingSdk, this.getAvailableProviders());
   }
   async getOrder(params) {
     const { orderBookApi } = this.config;
@@ -1123,14 +1197,11 @@ var BridgingSdk = class {
       orderId,
       orderBookApi,
       env,
-      providers: this.config.providers
+      providers: this.getAvailableProviders()
     });
   }
-  async getOrderBridgingStatus(bridgingId, originChainId) {
-    return this.provider.getStatus(bridgingId, originChainId);
-  }
   getProviderFromAppData(fullAppData) {
-    return findBridgeProviderFromHook(fullAppData, this.getProviders());
+    return findBridgeProviderFromHook(fullAppData, this.getAvailableProviders());
   }
   /**
    * Clear all caches. Useful for testing and debugging.
@@ -1156,7 +1227,25 @@ var BridgingSdk = class {
     };
   }
   getProviderByDappId(dappId) {
-    return this.config.providers.find((provider) => provider.info.dappId === dappId);
+    return this.getAvailableProviders().find((provider) => provider.info.dappId === dappId);
+  }
+  async getBuyTokensFromProvider(provider, params) {
+    const providerId = provider.info.dappId;
+    const cacheKey = getCacheKey({
+      id: providerId,
+      buyChainId: params.buyChainId.toString(),
+      sellChainId: params.sellChainId?.toString(),
+      tokenAddress: params.sellTokenAddress
+    });
+    const cached = this.cacheConfig.enabled && this.buyTokensCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const result = await provider.getBuyTokens(params);
+    if (this.cacheConfig.enabled) {
+      this.buyTokensCache.set(cacheKey, result);
+    }
+    return result;
   }
 };
 
@@ -1274,7 +1363,7 @@ var ACROSS_DEPOSIT_EVENT_INTERFACE = () => {
 };
 var COW_TRADE_EVENT_INTERFACE = () => {
   return (0, import_sdk_common7.getGlobalAdapter)().utils.createInterface([
-    "event Trade(address owner, address sellToken, address buyToken, uint256 sellAmount, uint256 buyAmount, uint256 feeAmount, bytes orderUid)"
+    "event Trade(address indexed owner, address sellToken, address buyToken, uint256 sellAmount, uint256 buyAmount, uint256 feeAmount, bytes orderUid)"
   ]);
 };
 
@@ -3398,8 +3487,9 @@ var import_sdk_order_book4 = require("@cowprotocol/sdk-order-book");
 var ACROSS_HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX}/across`;
 var ACROSS_SUPPORTED_NETWORKS = [import_sdk_config5.mainnet, import_sdk_config5.polygon, import_sdk_config5.arbitrumOne, import_sdk_config5.base, import_sdk_config5.optimism];
 var SLIPPAGE_TOLERANCE_BPS = 0;
+var providerType = "HookBridgeProvider";
 var AcrossBridgeProvider = class {
-  type = "HookBridgeProvider";
+  type = providerType;
   api;
   cowShedSdk;
   supportedTokens = null;
@@ -3415,7 +3505,8 @@ var AcrossBridgeProvider = class {
     name: "Across",
     logoUrl: `${RAW_PROVIDERS_FILES_PATH}/across/across-logo.png`,
     dappId: ACROSS_HOOK_DAPP_ID,
-    website: "https://across.to"
+    website: "https://across.to",
+    type: providerType
   };
   async getNetworks() {
     return ACROSS_SUPPORTED_NETWORKS;
@@ -3500,7 +3591,8 @@ var AcrossBridgeProvider = class {
   async decodeBridgeHook(_hook) {
     throw new Error("Not implemented");
   }
-  async getBridgingParams(chainId, orderUid, txHash) {
+  async getBridgingParams(chainId, order, txHash) {
+    const orderUid = order.uid;
     const adapter = (0, import_sdk_common12.getGlobalAdapter)();
     const txReceipt = await adapter.getTransactionReceipt(txHash);
     if (!txReceipt)
@@ -3660,6 +3752,7 @@ function toBridgeQuoteResult2(request, slippageBps, bungeeQuoteWithBuildTx) {
   const { kind } = request;
   const { bungeeQuote, buildTx } = bungeeQuoteWithBuildTx;
   return {
+    id: bungeeQuoteWithBuildTx.bungeeQuote.route.quoteId.toString(),
     isSell: kind === import_sdk_order_book5.OrderKind.SELL,
     amountsAndCosts: toAmountsAndCosts2(request, slippageBps, bungeeQuote),
     quoteTimestamp: Number(bungeeQuote.quoteTimestamp),
@@ -3688,7 +3781,7 @@ function toAmountsAndCosts2(request, slippageBps, bungeeQuote) {
   const buyAmountBeforeFee = (0, import_sdk_order_book5.getBigNumber)(buyAmountFromBungeeQuote, buyTokenDecimals).big;
   const buyAmountAfterFee = buyAmountBeforeFee;
   const feeSellToken = bungeeQuote.route.routeDetails.routeFee.amount;
-  const feeBuyToken = 0;
+  const feeBuyToken = sellAmountBeforeFee > 0n ? BigInt(feeSellToken) * buyAmountBeforeFee / sellAmountBeforeFee : 0n;
   const buyAmountAfterSlippage = applyBps2(buyAmountAfterFee, slippageBps);
   const bridgeFeeBps = calculateFeeBps(BigInt(bungeeQuote.route.routeDetails.routeFee.amount), BigInt(amount));
   return {
@@ -3708,7 +3801,7 @@ function toAmountsAndCosts2(request, slippageBps, bungeeQuote) {
       bridgingFee: {
         feeBps: bridgeFeeBps,
         amountInSellCurrency: BigInt(feeSellToken),
-        amountInBuyCurrency: BigInt(feeBuyToken)
+        amountInBuyCurrency: feeBuyToken
       }
     },
     slippageBps
@@ -4557,6 +4650,7 @@ var import_sdk_common15 = require("@cowprotocol/sdk-common");
 var BUNGEE_HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX2}/bungee`;
 var BUNGEE_SUPPORTED_NETWORKS = [import_sdk_config8.mainnet, import_sdk_config8.polygon, import_sdk_config8.arbitrumOne, import_sdk_config8.base, import_sdk_config8.optimism, import_sdk_config8.avalanche, import_sdk_config8.gnosisChain];
 var SLIPPAGE_TOLERANCE_BPS2 = 0;
+var providerType2 = "HookBridgeProvider";
 var BungeeBridgeProvider = class {
   constructor(options, _adapter) {
     this.options = options;
@@ -4567,14 +4661,15 @@ var BungeeBridgeProvider = class {
     this.api = new BungeeApi(options.apiOptions);
     this.cowShedSdk = new import_sdk_cow_shed2.CowShedSdk(adapter, options.cowShedOptions?.factoryOptions);
   }
-  type = "HookBridgeProvider";
+  type = providerType2;
   api;
   cowShedSdk;
   info = {
     name: "Bungee",
     logoUrl: `${RAW_PROVIDERS_FILES_PATH}/bungee/bungee-logo.png`,
     dappId: BUNGEE_HOOK_DAPP_ID,
-    website: "https://www.bungee.exchange"
+    website: "https://www.bungee.exchange",
+    type: providerType2
   };
   async getNetworks() {
     return BUNGEE_SUPPORTED_NETWORKS;
@@ -4668,7 +4763,8 @@ var BungeeBridgeProvider = class {
       recipient: cowShedAccount
     };
   }
-  async getBridgingParams(_chainId, orderId, _txHash) {
+  async getBridgingParams(_chainId, order, _txHash) {
+    const orderId = order.uid;
     const events = await this.api.getEvents({ orderId });
     const event = events?.[0];
     if (!event)
@@ -4710,6 +4806,416 @@ var BungeeBridgeProvider = class {
     return sellTokenChainId === import_sdk_config8.SupportedChainId.MAINNET && buyTokenChainId === import_sdk_config8.SupportedChainId.GNOSIS_CHAIN;
   }
 };
+
+// src/providers/near-intents/NearIntentsBridgeProvider.ts
+var import_sdk_common17 = require("@cowprotocol/sdk-common");
+var import_sdk_config11 = require("@cowprotocol/sdk-config");
+var import_sdk_cow_shed3 = require("@cowprotocol/sdk-cow-shed");
+var import_sdk_order_book7 = require("@cowprotocol/sdk-order-book");
+var import_one_click_sdk_typescript2 = require("@defuse-protocol/one-click-sdk-typescript");
+
+// src/providers/near-intents/NearIntentsApi.ts
+var import_one_click_sdk_typescript = require("@defuse-protocol/one-click-sdk-typescript");
+var NearIntentsApi = class {
+  cachedTokens = [];
+  async getTokens() {
+    if (this.cachedTokens.length === 0) {
+      const response = await import_one_click_sdk_typescript.OneClickService.getTokens();
+      this.cachedTokens = response;
+    }
+    return this.cachedTokens;
+  }
+  async getQuote(request) {
+    return await import_one_click_sdk_typescript.OneClickService.getQuote(request);
+  }
+  async getStatus(depositAddress) {
+    return await import_one_click_sdk_typescript.OneClickService.getExecutionStatus(depositAddress);
+  }
+  async getAttestation(request) {
+    const response = await fetch(`${import_one_click_sdk_typescript.OpenAPI.BASE}/v0/attestation`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    return await response.json();
+  }
+};
+
+// src/providers/near-intents/const/index.ts
+var import_sdk_config9 = require("@cowprotocol/sdk-config");
+var NEAR_INTENTS_HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX}/near-intents`;
+var NEAR_INTENTS_SUPPORTED_NETWORKS = [
+  import_sdk_config9.arbitrumOne,
+  import_sdk_config9.avalanche,
+  import_sdk_config9.base,
+  import_sdk_config9.bnb,
+  import_sdk_config9.gnosisChain,
+  import_sdk_config9.mainnet,
+  import_sdk_config9.optimism,
+  import_sdk_config9.polygon
+];
+var NEAR_INTENTS_BLOCKCHAIN_CHAIN_IDS = {
+  arb: import_sdk_config9.arbitrumOne.id,
+  avax: import_sdk_config9.avalanche.id,
+  base: import_sdk_config9.base.id,
+  bsc: import_sdk_config9.bnb.id,
+  eth: import_sdk_config9.mainnet.id,
+  gnosis: import_sdk_config9.gnosisChain.id,
+  op: import_sdk_config9.optimism.id,
+  pol: import_sdk_config9.polygon.id
+};
+var NEAR_INTENTS_STATUS_TO_COW_STATUS = {
+  KNOWN_DEPOSIT_TX: "in_progress" /* IN_PROGRESS */,
+  PENDING_DEPOSIT: "in_progress" /* IN_PROGRESS */,
+  INCOMPLETE_DEPOSIT: "unknown" /* UNKNOWN */,
+  PROCESSING: "in_progress" /* IN_PROGRESS */,
+  SUCCESS: "executed" /* EXECUTED */,
+  REFUNDED: "refund" /* REFUND */,
+  FAILED: "unknown" /* UNKNOWN */
+};
+var ATTESTATION_PREFIX_CONST = "0x0a773570";
+var ATTESTION_VERSION_BYTE = "0x00";
+var ATTESTATOR_ADDRESS = "0x0073DD100b51C555E41B2a452E5933ef76F42790";
+
+// src/providers/near-intents/util.ts
+var import_json_stable_stringify = __toESM(require("json-stable-stringify"));
+var import_sdk_common16 = require("@cowprotocol/sdk-common");
+var import_sdk_config10 = require("@cowprotocol/sdk-config");
+var calculateDeadline = (seconds) => {
+  const secs = Number(seconds);
+  if (!Number.isFinite(secs)) {
+    throw new Error(`Invalid seconds value: ${seconds}`);
+  }
+  const d = new Date(Date.now() + secs * 1e3);
+  return d.toISOString().replace(/\.\d{3}Z$/, "Z");
+};
+var adaptToken = (token) => {
+  const chainId = NEAR_INTENTS_BLOCKCHAIN_CHAIN_IDS[token.blockchain];
+  if (!chainId)
+    return null;
+  const tokenAddress = token.contractAddress || import_sdk_config10.ETH_ADDRESS;
+  if (!tokenAddress)
+    return null;
+  return {
+    chainId,
+    decimals: token.decimals,
+    address: tokenAddress,
+    name: token.symbol,
+    // TODO: how to handle? v0/tokens doesn't return the token name
+    symbol: token.symbol
+  };
+};
+var adaptTokens = (tokens) => tokens.reduce((acc, token) => {
+  const adaptedToken = adaptToken(token);
+  if (!adaptedToken)
+    return acc;
+  acc.push(adaptedToken);
+  return acc;
+}, []);
+var getTokenByAddressAndChainId = (tokens, targetTokenAddress, targetTokenChainId) => {
+  return tokens.find((token) => {
+    const chainId = NEAR_INTENTS_BLOCKCHAIN_CHAIN_IDS[token.blockchain];
+    if (!chainId)
+      return false;
+    if (targetTokenAddress.toLowerCase() === import_sdk_config10.ETH_ADDRESS.toLowerCase()) {
+      return chainId === targetTokenChainId && !token.contractAddress;
+    }
+    const tokenAddress = token.contractAddress || import_sdk_config10.ETH_ADDRESS;
+    return tokenAddress?.toLowerCase() === targetTokenAddress.toLowerCase() && chainId === targetTokenChainId;
+  });
+};
+var hashQuote = ({
+  quote,
+  quoteRequest,
+  timestamp
+}) => {
+  const adapter = (0, import_sdk_common16.getGlobalAdapter)();
+  const data = (0, import_json_stable_stringify.default)({
+    dry: false,
+    swapType: quoteRequest.swapType,
+    slippageTolerance: quoteRequest.slippageTolerance,
+    originAsset: quoteRequest.originAsset,
+    depositType: quoteRequest.depositType,
+    destinationAsset: quoteRequest.destinationAsset,
+    amount: quoteRequest.amount,
+    refundTo: quoteRequest.refundTo,
+    refundType: quoteRequest.refundType,
+    recipient: quoteRequest.recipient,
+    recipientType: quoteRequest.recipientType,
+    deadline: quoteRequest.deadline,
+    quoteWaitingTimeMs: !!quoteRequest.quoteWaitingTimeMs ? quoteRequest.quoteWaitingTimeMs : void 0,
+    referral: !!quoteRequest.referral ? quoteRequest.referral : void 0,
+    virtualChainRecipient: !!quoteRequest.virtualChainRecipient ? quoteRequest.virtualChainRecipient : void 0,
+    virtualChainRefundRecipient: !!quoteRequest.virtualChainRefundRecipient ? quoteRequest.virtualChainRefundRecipient : void 0,
+    customRecipientMsg: void 0,
+    sessionId: void 0,
+    connectedWallets: void 0,
+    depositMode: quoteRequest.depositMode,
+    amountIn: quote.amountIn,
+    amountInFormatted: quote.amountInFormatted,
+    amountInUsd: quote.amountInUsd,
+    minAmountIn: quote.minAmountIn,
+    amountOut: quote.amountOut,
+    amountOutFormatted: quote.amountOutFormatted,
+    amountOutUsd: quote.amountOutUsd,
+    minAmountOut: quote.minAmountOut,
+    timestamp
+  });
+  if (!data) {
+    throw new Error("Failed to serialize quote data: quote or quoteRequest may be undefined or invalid");
+  }
+  return adapter.utils.sha256(adapter.utils.toUtf8Bytes(data));
+};
+
+// src/providers/near-intents/NearIntentsBridgeProvider.ts
+var NEAR_INTENTS_HOOK_DAPP_ID2 = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX}/near-intents`;
+var REFERRAL = "cow";
+var providerType3 = "ReceiverAccountBridgeProvider";
+var NearIntentsBridgeProvider = class {
+  type = providerType3;
+  api;
+  cowShedSdk;
+  info = {
+    name: "Near Intents",
+    logoUrl: `${RAW_PROVIDERS_FILES_PATH}/near-intents/near-intents-logo.png`,
+    dappId: NEAR_INTENTS_HOOK_DAPP_ID2,
+    website: "https://www.near.org/intents",
+    type: providerType3
+  };
+  constructor(options, _adapter) {
+    const adapter = _adapter || options?.cowShedOptions?.adapter;
+    if (adapter) {
+      (0, import_sdk_common17.setGlobalAdapter)(adapter);
+    }
+    this.api = new NearIntentsApi();
+    this.cowShedSdk = new import_sdk_cow_shed3.CowShedSdk(adapter, options?.cowShedOptions?.factoryOptions);
+  }
+  async getNetworks() {
+    return NEAR_INTENTS_SUPPORTED_NETWORKS;
+  }
+  async getBuyTokens(params) {
+    const tokens = adaptTokens(await this.api.getTokens());
+    const filteredTokens = tokens.filter((token) => token.chainId === params.buyChainId);
+    return {
+      tokens: filteredTokens,
+      isRouteAvailable: filteredTokens.length > 0
+    };
+  }
+  async getIntermediateTokens(request) {
+    if (request.kind !== import_sdk_order_book7.OrderKind.SELL) {
+      throw new BridgeProviderQuoteError("ONLY_SELL_ORDER_SUPPORTED" /* ONLY_SELL_ORDER_SUPPORTED */, { kind: request.kind });
+    }
+    const { sellTokenChainId, buyTokenChainId, buyTokenAddress, sellTokenAddress } = request;
+    const tokens = adaptTokens(await this.api.getTokens());
+    const { sourceTokens, targetTokens } = tokens.reduce(
+      (acc, token) => {
+        if (token.chainId === sellTokenChainId) {
+          acc.sourceTokens.set(token.address.toLowerCase(), token);
+        }
+        if (token.chainId === buyTokenChainId) {
+          acc.targetTokens.set(token.address.toLowerCase(), token);
+        }
+        return acc;
+      },
+      {
+        sourceTokens: /* @__PURE__ */ new Map(),
+        targetTokens: /* @__PURE__ */ new Map()
+      }
+    );
+    const targetToken = targetTokens.get(buyTokenAddress.toLowerCase());
+    if (!targetToken)
+      return [];
+    return Array.from(sourceTokens.values()).filter((token) => {
+      return token.address?.toLowerCase() !== sellTokenAddress.toLowerCase();
+    });
+  }
+  async getQuote(request) {
+    const {
+      sellTokenAddress,
+      sellTokenChainId,
+      buyTokenAddress,
+      buyTokenChainId,
+      account,
+      amount,
+      receiver,
+      validFor,
+      owner
+    } = request;
+    const tokens = await this.api.getTokens();
+    const sellToken = getTokenByAddressAndChainId(tokens, sellTokenAddress, sellTokenChainId);
+    const buyToken = getTokenByAddressAndChainId(tokens, buyTokenAddress, buyTokenChainId);
+    if (!sellToken || !buyToken)
+      throw new BridgeProviderQuoteError("NO_ROUTES" /* NO_ROUTES */);
+    const quoteResponse = await this.api.getQuote({
+      dry: false,
+      swapType: import_one_click_sdk_typescript2.QuoteRequest.swapType.EXACT_INPUT,
+      slippageTolerance: request.slippageBps ?? 100,
+      originAsset: sellToken.assetId,
+      depositType: import_one_click_sdk_typescript2.QuoteRequest.depositType.ORIGIN_CHAIN,
+      destinationAsset: buyToken.assetId,
+      amount: amount.toString(),
+      refundTo: owner || account,
+      refundType: import_one_click_sdk_typescript2.QuoteRequest.refundType.ORIGIN_CHAIN,
+      recipient: receiver || account,
+      recipientType: import_one_click_sdk_typescript2.QuoteRequest.recipientType.DESTINATION_CHAIN,
+      deadline: calculateDeadline(validFor || 3600),
+      referral: REFERRAL
+    });
+    const recoveredDepositAddress = await this.recoverDepositAddress(quoteResponse);
+    if (recoveredDepositAddress?.address.toLowerCase() !== ATTESTATOR_ADDRESS.toLowerCase()) {
+      throw new BridgeProviderQuoteError("QUOTE_DOES_NOT_MATCH_DEPOSIT_ADDRESS" /* QUOTE_DOES_NOT_MATCH_DEPOSIT_ADDRESS */);
+    }
+    const { quote, timestamp: isoDate } = quoteResponse;
+    const payoutRatio = Number(quote.amountOutUsd) / Number(quote.amountInUsd);
+    const slippage = 1 - payoutRatio;
+    const slippageBps = Math.trunc(slippage * 1e4);
+    const feeAmountInBuyCurrency = Math.trunc(Number(quote.amountIn) * slippage);
+    const feeAmountInSellCurrency = Math.trunc(Number(quote.amountOut) * slippage);
+    const bridgeFee = Math.trunc(Number(quote.amountIn) * slippage);
+    return {
+      id: recoveredDepositAddress.quoteHash,
+      signature: quoteResponse.signature,
+      isSell: request.kind === import_sdk_order_book7.OrderKind.SELL,
+      depositAddress: quote.depositAddress,
+      quoteTimestamp: new Date(isoDate).getTime(),
+      expectedFillTimeSeconds: quote.timeEstimate,
+      limits: {
+        minDeposit: BigInt(quote.minAmountIn),
+        maxDeposit: BigInt(quote.amountIn)
+      },
+      fees: {
+        bridgeFee: BigInt(bridgeFee),
+        // The bridge fee is already included in `minAmountOut`. This means `bridgeFee` represents the maximum possible fee (worst case), but the actual fee may be lower.
+        destinationGasFee: BigInt(0)
+      },
+      amountsAndCosts: {
+        beforeFee: {
+          sellAmount: BigInt(quote.amountIn),
+          buyAmount: BigInt(quote.amountOut)
+        },
+        afterFee: {
+          sellAmount: BigInt(quote.amountIn),
+          buyAmount: BigInt(quote.minAmountOut)
+        },
+        afterSlippage: {
+          sellAmount: BigInt(quote.amountIn),
+          buyAmount: BigInt(quote.minAmountOut)
+        },
+        slippageBps,
+        costs: {
+          bridgingFee: {
+            feeBps: slippageBps,
+            amountInSellCurrency: BigInt(feeAmountInSellCurrency),
+            amountInBuyCurrency: BigInt(feeAmountInBuyCurrency)
+          }
+        }
+      }
+    };
+  }
+  async getBridgeReceiverOverride(_request, quote) {
+    return quote.depositAddress;
+  }
+  async getBridgingParams(_chainId, order, _txHash) {
+    const depositAddress = order.receiver;
+    if (!depositAddress)
+      return null;
+    const [tokens, status] = await Promise.all([this.api.getTokens(), this.api.getStatus(depositAddress)]);
+    const qr = status.quoteResponse?.quoteRequest;
+    const swapDetails = status.swapDetails;
+    const quote = status.quoteResponse?.quote;
+    const timestampMs = Date.parse(status.quoteResponse?.timestamp ?? "");
+    if (!qr || !quote || Number.isNaN(timestampMs)) {
+      throw new Error("Malformed quote response from NEAR Intents");
+    }
+    const quoteTimestamp = Math.floor(timestampMs / 1e3);
+    const inputToken = tokens.find((t) => t.assetId === qr.originAsset);
+    const outputToken = tokens.find((t) => t.assetId === qr.destinationAsset);
+    if (!inputToken || !outputToken)
+      throw new Error("Token not supported");
+    const adaptedInput = adaptToken(inputToken);
+    const adaptedOutput = adaptToken(outputToken);
+    if (!adaptedInput?.chainId || !adaptedOutput?.chainId) {
+      throw new Error("Token not supported");
+    }
+    return {
+      status: {
+        fillTimeInSeconds: quote.timeEstimate,
+        status: NEAR_INTENTS_STATUS_TO_COW_STATUS[status.status] ?? "unknown" /* UNKNOWN */,
+        fillTxHash: status.swapDetails?.destinationChainTxHashes?.[0]?.hash
+      },
+      params: {
+        inputTokenAddress: inputToken.contractAddress ?? import_sdk_config11.ETH_ADDRESS,
+        outputTokenAddress: outputToken.contractAddress ?? import_sdk_config11.ETH_ADDRESS,
+        inputAmount: BigInt(quote.amountIn),
+        outputAmount: swapDetails.amountOut ? BigInt(swapDetails.amountOut) : BigInt(quote.amountOut),
+        owner: order.owner,
+        quoteTimestamp,
+        fillDeadline: quoteTimestamp + quote.timeEstimate,
+        recipient: qr.recipient,
+        sourceChainId: adaptedInput.chainId,
+        destinationChainId: adaptedOutput.chainId,
+        bridgingId: depositAddress
+        // NEAR Intents deposit address
+      }
+    };
+  }
+  getExplorerUrl(bridgingId) {
+    return `https://explorer.near-intents.org/transactions/${bridgingId}`;
+  }
+  async getStatus(bridgingId, _originChainId) {
+    try {
+      const statusResponse = await this.api.getStatus(bridgingId);
+      return {
+        status: NEAR_INTENTS_STATUS_TO_COW_STATUS[statusResponse.status] || "unknown" /* UNKNOWN */,
+        depositTxHash: statusResponse.swapDetails?.originChainTxHashes[0]?.hash,
+        fillTxHash: statusResponse.swapDetails?.destinationChainTxHashes[0]?.hash
+      };
+    } catch {
+      return {
+        status: "unknown" /* UNKNOWN */
+      };
+    }
+  }
+  getCancelBridgingTx(_bridgingId) {
+    throw new Error("Not implemented");
+  }
+  getRefundBridgingTx(_bridgingId) {
+    throw new Error("Not implemented");
+  }
+  async recoverDepositAddress({
+    quote,
+    quoteRequest,
+    timestamp
+  }) {
+    try {
+      if (!quote?.depositAddress)
+        return null;
+      const utils = (0, import_sdk_common17.getGlobalAdapter)().utils;
+      const quoteHash = hashQuote({ quote, quoteRequest, timestamp });
+      const depositAddr = utils.getChecksumAddress(quote.depositAddress);
+      const { signature } = await this.api.getAttestation({
+        quoteHash,
+        depositAddress: depositAddr
+      });
+      if (!signature || !utils.isHexString(signature))
+        return null;
+      const payload = utils.hexConcat([depositAddr, quoteHash]);
+      const messageBytes = utils.hexConcat([ATTESTATION_PREFIX_CONST, ATTESTION_VERSION_BYTE, payload]);
+      const hash = utils.keccak256(messageBytes);
+      return {
+        address: await utils.recoverAddress(hash, signature),
+        quoteHash
+      };
+    } catch {
+      return null;
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AcrossBridgeProvider,
@@ -4725,6 +5231,7 @@ var BungeeBridgeProvider = class {
   DEFAULT_EXTRA_GAS_PROXY_CREATION,
   DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION,
   HOOK_DAPP_BRIDGE_PROVIDER_PREFIX,
+  NearIntentsBridgeProvider,
   RAW_PROVIDERS_FILES_PATH,
   assertIsBridgeQuoteAndPost,
   assertIsQuoteAndPost,