@cowprotocol/sdk-bridging 0.6.1 → 0.7.0

package/dist/index.mjs

@@ -18,6 +18,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 {
@@ -63,7 +64,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 [];
   }
@@ -93,14 +94,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);
 }
 
@@ -124,7 +129,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}`);
     }
@@ -282,6 +287,7 @@ async function getIntermediateSwapResult({
       metadata: {
         hooks,
         bridging: {
+          providerId: provider.info.dappId,
           destinationChainId: buyTokenChainId.toString(),
           destinationTokenAddress: buyTokenAddress
         }
@@ -323,7 +329,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 */);
@@ -378,13 +386,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 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: {
@@ -451,10 +468,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
     })
   };
 }
@@ -533,7 +552,9 @@ async function getQuoteWithHookBridge(provider, params) {
       getBridgeProviderQuote: (signer2, advancedSettings) => getBridgeProviderQuote(signer2, hookEstimatedGasLimit, advancedSettings),
       signer,
       sellTokenAddress: swapAndBridgeRequest.sellTokenAddress,
-      orderBookApi
+      orderBookApi,
+      provider,
+      initialSwapResult: result.swapResult
     })
   };
 }
@@ -620,10 +641,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) {
@@ -659,7 +679,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`, {}));
@@ -688,11 +708,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");
@@ -743,11 +763,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,
@@ -769,10 +789,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))
@@ -783,14 +803,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 ? {
@@ -799,7 +819,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,
@@ -829,11 +849,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,
@@ -852,20 +872,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
         };
@@ -875,7 +895,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,
@@ -913,10 +933,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;
@@ -963,18 +984,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.
@@ -986,7 +1007,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
@@ -994,22 +1029,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.
@@ -1032,7 +1077,8 @@ var BridgingSdk = class {
         quoteBridgeRequest,
         advancedSettings
       },
-      this.config
+      this.config.tradingSdk,
+      this.getAvailableProviders()
     );
   }
   /**
@@ -1051,7 +1097,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.
@@ -1069,7 +1115,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;
@@ -1079,14 +1125,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.
@@ -1112,7 +1155,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;
   }
 };
 
@@ -1230,55 +1291,55 @@ var ACROSS_DEPOSIT_EVENT_INTERFACE = () => {
 };
 var COW_TRADE_EVENT_INTERFACE = () => {
   return getGlobalAdapter4().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)"
   ]);
 };
 
 // src/providers/across/const/contracts.ts
-import { AdditionalTargetChainId, SupportedChainId as SupportedChainId2 } from "@cowprotocol/sdk-config";
+import { AdditionalTargetChainId, SupportedChainId } from "@cowprotocol/sdk-config";
 var ACROSS_SPOOK_CONTRACT_ADDRESSES = {
   // https://docs.across.to/reference/contract-addresses/mainnet-chain-id-1
-  [SupportedChainId2.MAINNET]: "0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5",
+  [SupportedChainId.MAINNET]: "0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5",
   // https://docs.across.to/reference/contract-addresses/arbitrum-chain-id-42161-1
-  [SupportedChainId2.ARBITRUM_ONE]: "0xe35e9842fceaca96570b734083f4a58e8f7c5f2a",
+  [SupportedChainId.ARBITRUM_ONE]: "0xe35e9842fceaca96570b734083f4a58e8f7c5f2a",
   // https://docs.across.to/reference/contract-addresses/base-chain-id-8453
-  [SupportedChainId2.BASE]: "0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64",
+  [SupportedChainId.BASE]: "0x09aea4b2242abC8bb4BB78D537A67a245A7bEC64",
   // // https://docs.across.to/reference/contract-addresses/mainnet-chain-id-1
-  [SupportedChainId2.SEPOLIA]: "0x5ef6C01E11889d86803e0B23e3cB3F9E9d97B662",
+  [SupportedChainId.SEPOLIA]: "0x5ef6C01E11889d86803e0B23e3cB3F9E9d97B662",
   // https://docs.across.to/reference/contract-addresses/polygon-chain-id-137
-  [SupportedChainId2.POLYGON]: "0x9295ee1d8C5b022Be115A2AD3c30C72E34e7F096",
+  [SupportedChainId.POLYGON]: "0x9295ee1d8C5b022Be115A2AD3c30C72E34e7F096",
   // https://docs.across.to/reference/contract-addresses/lens-chain-id-232
-  [SupportedChainId2.LENS]: "0xe7cb3e167e7475dE1331Cf6E0CEb187654619E12",
+  [SupportedChainId.LENS]: "0xe7cb3e167e7475dE1331Cf6E0CEb187654619E12",
   // https://docs.across.to/reference/contract-addresses/bnb-smart-chain
-  [SupportedChainId2.BNB]: "0x4e8E101924eDE233C13e2D8622DC8aED2872d505",
+  [SupportedChainId.BNB]: "0x4e8E101924eDE233C13e2D8622DC8aED2872d505",
   // https://docs.across.to/reference/contract-addresses/linea-chain-id-59144
-  [SupportedChainId2.LINEA]: "0xE0BCff426509723B18D6b2f0D8F4602d143bE3e0",
+  [SupportedChainId.LINEA]: "0xE0BCff426509723B18D6b2f0D8F4602d143bE3e0",
   // https://docs.across.to/reference/contract-addresses/plasma
-  [SupportedChainId2.PLASMA]: "0x50039fAEfebef707cFD94D6d462fE6D10B39207a",
+  [SupportedChainId.PLASMA]: "0x50039fAEfebef707cFD94D6d462fE6D10B39207a",
   // 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
-  [SupportedChainId2.GNOSIS_CHAIN]: void 0,
-  [SupportedChainId2.AVALANCHE]: void 0,
+  [SupportedChainId.GNOSIS_CHAIN]: void 0,
+  [SupportedChainId.AVALANCHE]: void 0,
   [AdditionalTargetChainId.OPTIMISM]: void 0
 };
 var ACROSS_MATH_CONTRACT_ADDRESSES = {
-  [SupportedChainId2.MAINNET]: "0xf2ae6728b6f146556977Af0A68bFbf5bADA22863",
-  [SupportedChainId2.ARBITRUM_ONE]: "0x5771A4b4029832e79a75De7B485E5fBbec28848f",
-  [SupportedChainId2.BASE]: "0xd4e943dc6ddc885f6229ce33c2e3dfe402a12c81",
+  [SupportedChainId.MAINNET]: "0xf2ae6728b6f146556977Af0A68bFbf5bADA22863",
+  [SupportedChainId.ARBITRUM_ONE]: "0x5771A4b4029832e79a75De7B485E5fBbec28848f",
+  [SupportedChainId.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
-  [SupportedChainId2.GNOSIS_CHAIN]: void 0,
-  [SupportedChainId2.SEPOLIA]: void 0,
-  [SupportedChainId2.POLYGON]: void 0,
+  [SupportedChainId.GNOSIS_CHAIN]: void 0,
+  [SupportedChainId.SEPOLIA]: void 0,
+  [SupportedChainId.POLYGON]: void 0,
   [AdditionalTargetChainId.OPTIMISM]: void 0,
-  [SupportedChainId2.AVALANCHE]: void 0,
-  [SupportedChainId2.LENS]: void 0,
+  [SupportedChainId.AVALANCHE]: void 0,
+  [SupportedChainId.LENS]: void 0,
   // TODO: confirm
-  [SupportedChainId2.BNB]: void 0,
+  [SupportedChainId.BNB]: void 0,
   // TODO: confirm
-  [SupportedChainId2.LINEA]: void 0,
+  [SupportedChainId.LINEA]: void 0,
   // TODO: confirm
-  [SupportedChainId2.PLASMA]: void 0
+  [SupportedChainId.PLASMA]: void 0
   // TODO: confirm
 };
 
@@ -3360,8 +3421,9 @@ import { OrderKind as OrderKind3 } from "@cowprotocol/sdk-order-book";
 var ACROSS_HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX}/across`;
 var ACROSS_SUPPORTED_NETWORKS = [mainnet, polygon, arbitrumOne, base, optimism];
 var SLIPPAGE_TOLERANCE_BPS = 0;
+var providerType = "HookBridgeProvider";
 var AcrossBridgeProvider = class {
-  type = "HookBridgeProvider";
+  type = providerType;
   api;
   cowShedSdk;
   supportedTokens = null;
@@ -3377,7 +3439,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;
@@ -3462,7 +3525,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 = getGlobalAdapter8();
     const txReceipt = await adapter.getTransactionReceipt(txHash);
     if (!txReceipt)
@@ -3650,7 +3714,7 @@ function toAmountsAndCosts2(request, slippageBps, bungeeQuote) {
   const buyAmountBeforeFee = getBigNumber2(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 {
@@ -3670,7 +3734,7 @@ function toAmountsAndCosts2(request, slippageBps, bungeeQuote) {
       bridgingFee: {
         feeBps: bridgeFeeBps,
         amountInSellCurrency: BigInt(feeSellToken),
-        amountInBuyCurrency: BigInt(feeBuyToken)
+        amountInBuyCurrency: feeBuyToken
       }
     },
     slippageBps
@@ -3723,62 +3787,62 @@ var getBungeeBridgeFromDisplayName = (displayName) => {
 };
 
 // src/providers/bungee/const/contracts.ts
-import { AdditionalTargetChainId as AdditionalTargetChainId2, SupportedChainId as SupportedChainId5 } from "@cowprotocol/sdk-config";
+import { AdditionalTargetChainId as AdditionalTargetChainId2, SupportedChainId as SupportedChainId4 } from "@cowprotocol/sdk-config";
 var BUNGEE_COWSWAP_LIB_ADDRESS = "0x75b6ba5fcab20848ca00f132d253638fea82e598";
 var BungeeCowswapLibAddresses = {
-  [SupportedChainId5.MAINNET]: BUNGEE_COWSWAP_LIB_ADDRESS,
-  [SupportedChainId5.GNOSIS_CHAIN]: BUNGEE_COWSWAP_LIB_ADDRESS,
-  [SupportedChainId5.ARBITRUM_ONE]: BUNGEE_COWSWAP_LIB_ADDRESS,
-  [SupportedChainId5.BASE]: BUNGEE_COWSWAP_LIB_ADDRESS,
-  [SupportedChainId5.AVALANCHE]: BUNGEE_COWSWAP_LIB_ADDRESS,
-  [SupportedChainId5.POLYGON]: BUNGEE_COWSWAP_LIB_ADDRESS,
-  [SupportedChainId5.LENS]: void 0,
+  [SupportedChainId4.MAINNET]: BUNGEE_COWSWAP_LIB_ADDRESS,
+  [SupportedChainId4.GNOSIS_CHAIN]: BUNGEE_COWSWAP_LIB_ADDRESS,
+  [SupportedChainId4.ARBITRUM_ONE]: BUNGEE_COWSWAP_LIB_ADDRESS,
+  [SupportedChainId4.BASE]: BUNGEE_COWSWAP_LIB_ADDRESS,
+  [SupportedChainId4.AVALANCHE]: BUNGEE_COWSWAP_LIB_ADDRESS,
+  [SupportedChainId4.POLYGON]: BUNGEE_COWSWAP_LIB_ADDRESS,
+  [SupportedChainId4.LENS]: void 0,
   // TODO: confirm
-  [SupportedChainId5.BNB]: void 0,
+  [SupportedChainId4.BNB]: void 0,
   // TODO: confirm
-  [SupportedChainId5.LINEA]: void 0,
+  [SupportedChainId4.LINEA]: void 0,
   // TODO: confirm
-  [SupportedChainId5.PLASMA]: void 0,
+  [SupportedChainId4.PLASMA]: void 0,
   // TODO: confirm
-  [SupportedChainId5.SEPOLIA]: void 0,
+  [SupportedChainId4.SEPOLIA]: void 0,
   [AdditionalTargetChainId2.OPTIMISM]: BUNGEE_COWSWAP_LIB_ADDRESS
 };
 var SOCKET_VERIFIER_ADDRESS = "0xa27A3f5A96DF7D8Be26EE2790999860C00eb688D";
 var SocketVerifierAddresses = {
-  [SupportedChainId5.MAINNET]: SOCKET_VERIFIER_ADDRESS,
-  [SupportedChainId5.GNOSIS_CHAIN]: SOCKET_VERIFIER_ADDRESS,
-  [SupportedChainId5.ARBITRUM_ONE]: SOCKET_VERIFIER_ADDRESS,
-  [SupportedChainId5.BASE]: SOCKET_VERIFIER_ADDRESS,
-  [SupportedChainId5.AVALANCHE]: SOCKET_VERIFIER_ADDRESS,
-  [SupportedChainId5.POLYGON]: SOCKET_VERIFIER_ADDRESS,
-  [SupportedChainId5.LENS]: void 0,
+  [SupportedChainId4.MAINNET]: SOCKET_VERIFIER_ADDRESS,
+  [SupportedChainId4.GNOSIS_CHAIN]: SOCKET_VERIFIER_ADDRESS,
+  [SupportedChainId4.ARBITRUM_ONE]: SOCKET_VERIFIER_ADDRESS,
+  [SupportedChainId4.BASE]: SOCKET_VERIFIER_ADDRESS,
+  [SupportedChainId4.AVALANCHE]: SOCKET_VERIFIER_ADDRESS,
+  [SupportedChainId4.POLYGON]: SOCKET_VERIFIER_ADDRESS,
+  [SupportedChainId4.LENS]: void 0,
   // TODO: confirm
-  [SupportedChainId5.BNB]: void 0,
+  [SupportedChainId4.BNB]: void 0,
   // TODO: confirm
-  [SupportedChainId5.LINEA]: void 0,
+  [SupportedChainId4.LINEA]: void 0,
   // TODO: confirm
-  [SupportedChainId5.PLASMA]: void 0,
+  [SupportedChainId4.PLASMA]: void 0,
   // TODO: confirm
-  [SupportedChainId5.SEPOLIA]: void 0,
+  [SupportedChainId4.SEPOLIA]: void 0,
   [AdditionalTargetChainId2.OPTIMISM]: SOCKET_VERIFIER_ADDRESS
 };
 var BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS = "0xD06a673fe1fa27B1b9E5BA0be980AB15Dbce85cc";
 var BungeeApproveAndBridgeV1Addresses = {
-  [SupportedChainId5.MAINNET]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
-  [SupportedChainId5.GNOSIS_CHAIN]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
-  [SupportedChainId5.ARBITRUM_ONE]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
-  [SupportedChainId5.BASE]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
-  [SupportedChainId5.AVALANCHE]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
-  [SupportedChainId5.POLYGON]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
-  [SupportedChainId5.LENS]: void 0,
+  [SupportedChainId4.MAINNET]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
+  [SupportedChainId4.GNOSIS_CHAIN]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
+  [SupportedChainId4.ARBITRUM_ONE]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
+  [SupportedChainId4.BASE]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
+  [SupportedChainId4.AVALANCHE]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
+  [SupportedChainId4.POLYGON]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS,
+  [SupportedChainId4.LENS]: void 0,
   // TODO: confirm
-  [SupportedChainId5.BNB]: void 0,
+  [SupportedChainId4.BNB]: void 0,
   // TODO: confirm
-  [SupportedChainId5.LINEA]: void 0,
+  [SupportedChainId4.LINEA]: void 0,
   // TODO: confirm
-  [SupportedChainId5.PLASMA]: void 0,
+  [SupportedChainId4.PLASMA]: void 0,
   // TODO: confirm
-  [SupportedChainId5.SEPOLIA]: void 0,
+  [SupportedChainId4.SEPOLIA]: void 0,
   [AdditionalTargetChainId2.OPTIMISM]: BUNGEE_APPROVE_AND_BRIDGE_V1_ADDRESS
 };
 
@@ -4521,13 +4585,14 @@ import {
   mainnet as mainnet2,
   optimism as optimism2,
   polygon as polygon2,
-  SupportedChainId as SupportedChainId6
+  SupportedChainId as SupportedChainId5
 } from "@cowprotocol/sdk-config";
 import { CowShedSdk as CowShedSdk2 } from "@cowprotocol/sdk-cow-shed";
 import { setGlobalAdapter as setGlobalAdapter3 } from "@cowprotocol/sdk-common";
 var BUNGEE_HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX2}/bungee`;
 var BUNGEE_SUPPORTED_NETWORKS = [mainnet2, polygon2, arbitrumOne2, base2, optimism2, avalanche, gnosisChain];
 var SLIPPAGE_TOLERANCE_BPS2 = 0;
+var providerType2 = "HookBridgeProvider";
 var BungeeBridgeProvider = class {
   constructor(options, _adapter) {
     this.options = options;
@@ -4538,14 +4603,15 @@ var BungeeBridgeProvider = class {
     this.api = new BungeeApi(options.apiOptions);
     this.cowShedSdk = new CowShedSdk2(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;
@@ -4639,7 +4705,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)
@@ -4678,7 +4745,408 @@ var BungeeBridgeProvider = class {
   }
   isExtraGasRequired(request) {
     const { sellTokenChainId, buyTokenChainId } = request;
-    return sellTokenChainId === SupportedChainId6.MAINNET && buyTokenChainId === SupportedChainId6.GNOSIS_CHAIN;
+    return sellTokenChainId === SupportedChainId5.MAINNET && buyTokenChainId === SupportedChainId5.GNOSIS_CHAIN;
+  }
+};
+
+// src/providers/near-intents/NearIntentsBridgeProvider.ts
+import { getGlobalAdapter as getGlobalAdapter12, setGlobalAdapter as setGlobalAdapter4 } from "@cowprotocol/sdk-common";
+import { ETH_ADDRESS as ETH_ADDRESS3 } from "@cowprotocol/sdk-config";
+import { CowShedSdk as CowShedSdk3 } from "@cowprotocol/sdk-cow-shed";
+import { OrderKind as OrderKind6 } from "@cowprotocol/sdk-order-book";
+import { QuoteRequest } from "@defuse-protocol/one-click-sdk-typescript";
+
+// src/providers/near-intents/NearIntentsApi.ts
+import { OneClickService, OpenAPI } from "@defuse-protocol/one-click-sdk-typescript";
+var NearIntentsApi = class {
+  cachedTokens = [];
+  async getTokens() {
+    if (this.cachedTokens.length === 0) {
+      const response = await OneClickService.getTokens();
+      this.cachedTokens = response;
+    }
+    return this.cachedTokens;
+  }
+  async getQuote(request) {
+    return await OneClickService.getQuote(request);
+  }
+  async getStatus(depositAddress) {
+    return await OneClickService.getExecutionStatus(depositAddress);
+  }
+  async getAttestation(request) {
+    const response = await fetch(`${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
+import { arbitrumOne as arbitrumOne3, avalanche as avalanche2, base as base3, bnb, gnosisChain as gnosisChain2, mainnet as mainnet3, optimism as optimism3, polygon as polygon3 } from "@cowprotocol/sdk-config";
+var NEAR_INTENTS_HOOK_DAPP_ID = `${HOOK_DAPP_BRIDGE_PROVIDER_PREFIX}/near-intents`;
+var NEAR_INTENTS_SUPPORTED_NETWORKS = [
+  arbitrumOne3,
+  avalanche2,
+  base3,
+  bnb,
+  gnosisChain2,
+  mainnet3,
+  optimism3,
+  polygon3
+];
+var NEAR_INTENTS_BLOCKCHAIN_CHAIN_IDS = {
+  arb: arbitrumOne3.id,
+  avax: avalanche2.id,
+  base: base3.id,
+  bsc: bnb.id,
+  eth: mainnet3.id,
+  gnosis: gnosisChain2.id,
+  op: optimism3.id,
+  pol: polygon3.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
+import stringify from "json-stable-stringify";
+import { getGlobalAdapter as getGlobalAdapter11 } from "@cowprotocol/sdk-common";
+import { ETH_ADDRESS as ETH_ADDRESS2 } from "@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 || ETH_ADDRESS2;
+  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() === ETH_ADDRESS2.toLowerCase()) {
+      return chainId === targetTokenChainId && !token.contractAddress;
+    }
+    const tokenAddress = token.contractAddress || ETH_ADDRESS2;
+    return tokenAddress?.toLowerCase() === targetTokenAddress.toLowerCase() && chainId === targetTokenChainId;
+  });
+};
+var hashQuote = ({
+  quote,
+  quoteRequest,
+  timestamp
+}) => {
+  const adapter = getGlobalAdapter11();
+  const data = stringify({
+    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) {
+      setGlobalAdapter4(adapter);
+    }
+    this.api = new NearIntentsApi();
+    this.cowShedSdk = new CowShedSdk3(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 !== OrderKind6.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: QuoteRequest.swapType.EXACT_INPUT,
+      slippageTolerance: request.slippageBps ?? 100,
+      originAsset: sellToken.assetId,
+      depositType: QuoteRequest.depositType.ORIGIN_CHAIN,
+      destinationAsset: buyToken.assetId,
+      amount: amount.toString(),
+      refundTo: owner || account,
+      refundType: QuoteRequest.refundType.ORIGIN_CHAIN,
+      recipient: receiver || account,
+      recipientType: QuoteRequest.recipientType.DESTINATION_CHAIN,
+      deadline: calculateDeadline(validFor || 3600),
+      referral: REFERRAL
+    });
+    const recoveredDepositAddress = await this.recoverDepositAddress(quoteResponse);
+    if (recoveredDepositAddress?.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 {
+      isSell: request.kind === OrderKind6.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 ?? ETH_ADDRESS3,
+        outputTokenAddress: outputToken.contractAddress ?? ETH_ADDRESS3,
+        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 = getGlobalAdapter12().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 utils.recoverAddress(hash, signature);
+    } catch {
+      return null;
+    }
   }
 };
 export {
@@ -4695,6 +5163,7 @@ export {
   DEFAULT_EXTRA_GAS_PROXY_CREATION,
   DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION,
   HOOK_DAPP_BRIDGE_PROVIDER_PREFIX,
+  NearIntentsBridgeProvider,
   RAW_PROVIDERS_FILES_PATH,
   assertIsBridgeQuoteAndPost,
   assertIsQuoteAndPost,