feat: add Bitcoin and Solana support into NearIntentsProvider

packages/bridging/src/providers/near-intents/NearIntentsApi.test.ts

@@ -42,7 +42,6 @@ describe('NearIntentsApi', () => {
   })
 
   it("doesn't add Authorization header when api key is not set", async () => {
-
     const api = new NearIntentsApi()
 
     mockFetch.mockResolvedValue({
@@ -70,4 +69,3 @@ describe('NearIntentsApi', () => {
     )
   })
 })
-

packages/bridging/src/providers/near-intents/NearIntentsBridgeProvider.test.ts

@@ -1,5 +1,10 @@
 import { setGlobalAdapter } from '@cowprotocol/sdk-common'
-import { SupportedChainId } from '@cowprotocol/sdk-config'
+import {
+  BTC_CURRENCY_ADDRESS,
+  NonEvmChains,
+  SOL_NATIVE_CURRENCY_ADDRESS,
+  SupportedChainId,
+} from '@cowprotocol/sdk-config'
 import { GetExecutionStatusResponse, QuoteRequest, TokenResponse } from '@defuse-protocol/one-click-sdk-typescript'
 
 import { createAdapters } from '../../../tests/setup'
@@ -386,6 +391,230 @@ adapterNames.forEach((adapterName) => {
         expect(result?.address).toBeDefined()
         expect(result?.address.length).toBeGreaterThan(0)
       })
+
+      it('should return quote when destination asset is bitcoin', async () => {
+        const api = new NearIntentsApi()
+        const sellTokenAddress = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'
+        const buyTokenAddress = BTC_CURRENCY_ADDRESS
+        const testQuoteHash = '0xtestBtcQuoteHash123'
+
+        const mockQuoteResponse: QuoteResponse = {
+          quote: {
+            amountIn: '1000000',
+            amountInFormatted: '1.0',
+            amountInUsd: '1.0',
+            minAmountIn: '1000000',
+            amountOut: '10000',
+            amountOutFormatted: '0.0001',
+            amountOutUsd: '1.0',
+            minAmountOut: '9900',
+            timeEstimate: 600,
+            deadline: '2025-09-05T12:10:38.605Z',
+            timeWhenInactive: '2025-09-05T12:10:38.605Z',
+            depositAddress: '0xAd8b7139196c5ae9fb66B71C91d87A1F9071687e',
+          },
+          quoteRequest: {
+            dry: false,
+            swapType: QuoteRequest.swapType.EXACT_INPUT,
+            depositMode: QuoteRequest.depositMode.SIMPLE,
+            slippageTolerance: 100,
+            originAsset: 'nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near',
+            depositType: QuoteRequest.depositType.ORIGIN_CHAIN,
+            destinationAsset: 'nep141:btc.omft.near',
+            amount: '1000000',
+            refundTo: '0x0000000000000000000000000000000000000000',
+            refundType: QuoteRequest.refundType.ORIGIN_CHAIN,
+            recipient: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
+            recipientType: QuoteRequest.recipientType.DESTINATION_CHAIN,
+            deadline: '2025-09-05T12:10:38.605Z',
+          },
+          signature: 'ed25519:testBtcSignature',
+          timestamp: '2025-09-05T12:00:38.695Z',
+        }
+
+        jest.spyOn(api, 'getQuote').mockResolvedValue(mockQuoteResponse)
+        jest.spyOn(api, 'getTokens').mockResolvedValue([
+          {
+            assetId: 'nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near',
+            decimals: 6,
+            blockchain: TokenResponse.blockchain.BASE,
+            symbol: 'USDC',
+            price: 1,
+            priceUpdatedAt: '2025-09-05T12:00:38.695Z',
+            contractAddress: sellTokenAddress,
+          },
+          {
+            assetId: 'nep141:btc.omft.near',
+            decimals: 8,
+            blockchain: TokenResponse.blockchain.BTC,
+            symbol: 'BTC',
+            price: 60000,
+            priceUpdatedAt: '2025-09-05T12:00:38.695Z',
+          },
+        ])
+        jest.spyOn(api, 'getAttestation').mockResolvedValue({
+          version: 1,
+          signature:
+            '0x66edc32e2ab001213321ab7d959a2207fcef5190cc9abb6da5b0d2a8a9af2d4d2b0700e2c317c4106f337fd934fbbb0bf62efc8811a78603b33a8265d3b8f8cb1c',
+        })
+        provider.setApi(api)
+
+        jest.spyOn(provider, 'recoverDepositAddress').mockResolvedValue({
+          address: ATTESTATOR_ADDRESS,
+          quoteHash: testQuoteHash,
+          stringifiedQuote: '',
+          attestationSignature: '',
+        })
+
+        const quote = await provider.getQuote({
+          kind: OrderKind.SELL,
+          sellTokenChainId: SupportedChainId.BASE,
+          sellTokenAddress,
+          sellTokenDecimals: 6,
+          buyTokenChainId: NonEvmChains.BITCOIN as number,
+          buyTokenAddress,
+          buyTokenDecimals: 8,
+          amount: 1000000n,
+          account: '0x0000000000000000000000000000000000000000',
+          appCode: 'test',
+          signer: '0x0000000000000000000000000000000000000000',
+        })
+
+        expect(quote.id).toBe(testQuoteHash)
+        expect(quote.signature).toBe('ed25519:testBtcSignature')
+        expect(quote.depositAddress).toBe('0xAd8b7139196c5ae9fb66B71C91d87A1F9071687e')
+        expect(quote.amountsAndCosts.beforeFee.buyAmount).toBe(10000n)
+      })
+
+      it('should return quote when destination asset is solana', async () => {
+        const api = new NearIntentsApi()
+        const sellTokenAddress = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'
+        const buyTokenAddress = SOL_NATIVE_CURRENCY_ADDRESS
+        const testQuoteHash = '0xtestSolQuoteHash123'
+
+        const mockQuoteResponse: QuoteResponse = {
+          quote: {
+            amountIn: '1000000',
+            amountInFormatted: '1.0',
+            amountInUsd: '1.0',
+            minAmountIn: '1000000',
+            amountOut: '100000000',
+            amountOutFormatted: '1.0',
+            amountOutUsd: '1.0',
+            minAmountOut: '99000000',
+            timeEstimate: 60,
+            deadline: '2025-09-05T12:10:38.605Z',
+            timeWhenInactive: '2025-09-05T12:10:38.605Z',
+            depositAddress: '0xAd8b7139196c5ae9fb66B71C91d87A1F9071687e',
+          },
+          quoteRequest: {
+            dry: false,
+            swapType: QuoteRequest.swapType.EXACT_INPUT,
+            depositMode: QuoteRequest.depositMode.SIMPLE,
+            slippageTolerance: 100,
+            originAsset: 'nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near',
+            depositType: QuoteRequest.depositType.ORIGIN_CHAIN,
+            destinationAsset: 'nep141:sol.omft.near',
+            amount: '1000000',
+            refundTo: '0x0000000000000000000000000000000000000000',
+            refundType: QuoteRequest.refundType.ORIGIN_CHAIN,
+            recipient: 'So11111111111111111111111111111111111111112',
+            recipientType: QuoteRequest.recipientType.DESTINATION_CHAIN,
+            deadline: '2025-09-05T12:10:38.605Z',
+          },
+          signature: 'ed25519:testSolSignature',
+          timestamp: '2025-09-05T12:00:38.695Z',
+        }
+
+        jest.spyOn(api, 'getQuote').mockResolvedValue(mockQuoteResponse)
+        jest.spyOn(api, 'getTokens').mockResolvedValue([
+          {
+            assetId: 'nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near',
+            decimals: 6,
+            blockchain: TokenResponse.blockchain.BASE,
+            symbol: 'USDC',
+            price: 1,
+            priceUpdatedAt: '2025-09-05T12:00:38.695Z',
+            contractAddress: sellTokenAddress,
+          },
+          {
+            assetId: 'nep141:sol.omft.near',
+            decimals: 9,
+            blockchain: TokenResponse.blockchain.SOL,
+            symbol: 'SOL',
+            price: 150,
+            priceUpdatedAt: '2025-09-05T12:00:38.695Z',
+          },
+        ])
+        jest.spyOn(api, 'getAttestation').mockResolvedValue({
+          version: 1,
+          signature:
+            '0x66edc32e2ab001213321ab7d959a2207fcef5190cc9abb6da5b0d2a8a9af2d4d2b0700e2c317c4106f337fd934fbbb0bf62efc8811a78603b33a8265d3b8f8cb1c',
+        })
+        provider.setApi(api)
+
+        jest.spyOn(provider, 'recoverDepositAddress').mockResolvedValue({
+          address: ATTESTATOR_ADDRESS,
+          quoteHash: testQuoteHash,
+          stringifiedQuote: '',
+          attestationSignature: '',
+        })
+
+        const quote = await provider.getQuote({
+          kind: OrderKind.SELL,
+          sellTokenChainId: SupportedChainId.BASE,
+          sellTokenAddress,
+          sellTokenDecimals: 6,
+          buyTokenChainId: NonEvmChains.SOLANA as number,
+          buyTokenAddress,
+          buyTokenDecimals: 9,
+          amount: 1000000n,
+          account: '0x0000000000000000000000000000000000000000',
+          appCode: 'test',
+          signer: '0x0000000000000000000000000000000000000000',
+        })
+
+        expect(quote.id).toBe(testQuoteHash)
+        expect(quote.signature).toBe('ed25519:testSolSignature')
+        expect(quote.depositAddress).toBe('0xAd8b7139196c5ae9fb66B71C91d87A1F9071687e')
+        expect(quote.amountsAndCosts.beforeFee.buyAmount).toBe(100000000n)
+      })
+
+      it('should throw NO_ROUTES when sellTokenAddress is BTC_CURRENCY_ADDRESS', async () => {
+        await expect(
+          provider.getQuote({
+            kind: OrderKind.SELL,
+            sellTokenChainId: SupportedChainId.BASE,
+            sellTokenAddress: BTC_CURRENCY_ADDRESS,
+            sellTokenDecimals: 8,
+            buyTokenChainId: SupportedChainId.BASE,
+            buyTokenAddress: '0x4200000000000000000000000000000000000006',
+            buyTokenDecimals: 18,
+            amount: 1000000n,
+            account: '0x0000000000000000000000000000000000000000',
+            appCode: 'test',
+            signer: '0x0000000000000000000000000000000000000000',
+          }),
+        ).rejects.toThrow('NO_ROUTES')
+      })
+
+      it('should throw NO_ROUTES when sellTokenAddress is SOL_NATIVE_CURRENCY_ADDRESS', async () => {
+        await expect(
+          provider.getQuote({
+            kind: OrderKind.SELL,
+            sellTokenChainId: SupportedChainId.BASE,
+            sellTokenAddress: SOL_NATIVE_CURRENCY_ADDRESS,
+            sellTokenDecimals: 9,
+            buyTokenChainId: SupportedChainId.BASE,
+            buyTokenAddress: '0x4200000000000000000000000000000000000006',
+            buyTokenDecimals: 18,
+            amount: 1000000n,
+            account: '0x0000000000000000000000000000000000000000',
+            appCode: 'test',
+            signer: '0x0000000000000000000000000000000000000000',
+          }),
+        ).rejects.toThrow('NO_ROUTES')
+      })
     })
   })
 })

packages/bridging/src/providers/near-intents/NearIntentsBridgeProvider.ts

@@ -1,5 +1,5 @@
 import { getGlobalAdapter, setGlobalAdapter } from '@cowprotocol/sdk-common'
-import { ETH_ADDRESS } from '@cowprotocol/sdk-config'
+import { BTC_CURRENCY_ADDRESS, ETH_ADDRESS, SOL_NATIVE_CURRENCY_ADDRESS } from '@cowprotocol/sdk-config'
 import { CowShedSdk } from '@cowprotocol/sdk-cow-shed'
 import { EnrichedOrder, OrderKind } from '@cowprotocol/sdk-order-book'
 import { QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript'
@@ -138,6 +138,10 @@ export class NearIntentsBridgeProvider implements ReceiverAccountBridgeProvider<
       owner,
     } = request
 
+    if (sellTokenAddress === BTC_CURRENCY_ADDRESS || sellTokenAddress === SOL_NATIVE_CURRENCY_ADDRESS) {
+      throw new BridgeProviderQuoteError(BridgeQuoteErrors.NO_ROUTES)
+    }
+
     const tokens = await this.api.getTokens()
     const sellToken = getTokenByAddressAndChainId(tokens, sellTokenAddress, sellTokenChainId)
     const buyToken = getTokenByAddressAndChainId(tokens, buyTokenAddress, buyTokenChainId)

packages/bridging/src/providers/near-intents/const/index.ts

@@ -1,4 +1,17 @@
-import { arbitrumOne, avalanche, base, bnb, gnosisChain, mainnet, optimism, polygon, plasma } from '@cowprotocol/sdk-config'
+import {
+  arbitrumOne,
+  avalanche,
+  base,
+  bnb,
+  gnosisChain,
+  mainnet,
+  optimism,
+  polygon,
+  plasma,
+  bitcoin,
+  solana,
+  ChainId,
+} from '@cowprotocol/sdk-config'
 
 import { HOOK_DAPP_BRIDGE_PROVIDER_PREFIX } from '../../../const'
 
@@ -16,9 +29,22 @@ export const NEAR_INTENTS_SUPPORTED_NETWORKS = [
   optimism,
   polygon,
   plasma,
+  bitcoin,
+  solana,
 ]
 
-export type NearBlockchainKey = 'arb' | 'avax' | 'base' | 'bsc' | 'eth' | 'gnosis' | 'op' | 'pol' | 'plasma'
+export type NearBlockchainKey =
+  | 'arb'
+  | 'avax'
+  | 'base'
+  | 'bsc'
+  | 'eth'
+  | 'gnosis'
+  | 'op'
+  | 'pol'
+  | 'plasma'
+  | 'btc'
+  | 'sol'
 
 export const NEAR_INTENTS_BLOCKCHAIN_CHAIN_IDS = {
   arb: arbitrumOne.id,
@@ -30,7 +56,9 @@ export const NEAR_INTENTS_BLOCKCHAIN_CHAIN_IDS = {
   op: optimism.id,
   pol: polygon.id,
   plasma: plasma.id,
-} as const satisfies Record<NearBlockchainKey, number>
+  btc: bitcoin.id,
+  sol: solana.id,
+} as const satisfies Record<NearBlockchainKey, ChainId>
 
 export const NEAR_INTENTS_STATUS_TO_COW_STATUS: Record<string, BridgeStatus> = {
   KNOWN_DEPOSIT_TX: BridgeStatus.IN_PROGRESS,

packages/bridging/src/providers/near-intents/util.test.ts

@@ -46,11 +46,11 @@ describe('Near Intents Utils', () => {
 
     it('should return null for a non supported chain', () => {
       const tokenResponse: TokenResponse = {
-        assetId: 'nep141:sol.omft.near',
+        assetId: 'nep141:ton.omft.near',
         decimals: 9,
-        blockchain: TokenResponse.blockchain.SOL,
-        symbol: 'SOL',
-        price: 234.78,
+        blockchain: TokenResponse.blockchain.TON,
+        symbol: 'TON',
+        price: 5.0,
         priceUpdatedAt: '2025-09-12T04:08:30.252Z',
       }
 

packages/bridging/src/providers/near-intents/util.ts

@@ -1,7 +1,14 @@
 import stringify from 'json-stable-stringify'
 import type { Quote, QuoteRequest, TokenResponse } from '@defuse-protocol/one-click-sdk-typescript'
 import { getGlobalAdapter } from '@cowprotocol/sdk-common'
-import { ETH_ADDRESS, TokenInfo, ChainId, isEvmChain } from '@cowprotocol/sdk-config'
+import {
+  BTC_CURRENCY_ADDRESS,
+  ETH_ADDRESS,
+  SOL_NATIVE_CURRENCY_ADDRESS,
+  TokenInfo,
+  ChainId,
+  isEvmChain,
+} from '@cowprotocol/sdk-config'
 import type { Hex } from 'viem'
 
 import { NEAR_INTENTS_BLOCKCHAIN_CHAIN_IDS } from './const'
@@ -45,18 +52,27 @@ export const getTokenByAddressAndChainId = (
   targetTokenAddress: string,
   targetTokenChainId: ChainId,
 ): TokenResponse | undefined => {
-  // will handle non-EVM chains in the future
-  if (!isEvmChain(targetTokenChainId)) {
-    return undefined
-  }
   return tokens.find((token) => {
     const chainId = NEAR_INTENTS_BLOCKCHAIN_CHAIN_IDS[token.blockchain as NearBlockchainKey]
     if (!chainId) return false
+    if (chainId !== targetTokenChainId) return false
+
+    // For non-EVM chains, match native tokens (no contractAddress) against known native sentinels,
+    // or match SPL/other tokens by contractAddress directly
+    if (!isEvmChain(targetTokenChainId)) {
+      if (!token.contractAddress) {
+        return targetTokenAddress === BTC_CURRENCY_ADDRESS || targetTokenAddress === SOL_NATIVE_CURRENCY_ADDRESS
+      }
+      return token.contractAddress.toLowerCase() === targetTokenAddress.toLowerCase()
+    }
+
+    // Match native/unwrapped EVM tokens (no contractAddress) via ETH_ADDRESS sentinel
     if (targetTokenAddress.toLowerCase() === ETH_ADDRESS.toLowerCase()) {
-      return chainId === targetTokenChainId && !token.contractAddress
+      return !token.contractAddress
     }
+
     const tokenAddress = token.contractAddress || ETH_ADDRESS
-    return tokenAddress?.toLowerCase() === targetTokenAddress.toLowerCase() && chainId === targetTokenChainId
+    return tokenAddress?.toLowerCase() === targetTokenAddress.toLowerCase()
   })
 }