feat(bridge): update Across bridge provider

packages/bridging/src/BridgingSdk/getCrossChainOrder.ts

@@ -67,7 +67,7 @@ export async function getCrossChainOrder(params: GetCrossChainOrderParams): Prom
     }
 
     try {
-      const explorerUrl = provider.getExplorerUrl(bridgingParams.bridgingId)
+      const explorerUrl = provider.getExplorerUrl(bridgingParams.bridgingId, tradeTxHash)
 
       return {
         ...state,

packages/bridging/src/providers/across/AcrossApi.spec.ts

@@ -15,7 +15,8 @@ describe('AcrossApi: Shape of API response', () => {
     // Attempt to make a REAL API call. The API implementation will assert the result shape matches the expected object
     //  Example: https://app.across.to/api/suggested-fees?token=0x82aF49447D8a07e3bd95BD0d56f35241523fBab1&originChainId=42161&destinationChainId=8453&amount=2389939424141418&recipient=0x016f34D4f2578c3e9DFfC3f2b811Ba30c0c9e7f3
     const result = await api.getSuggestedFees({
-      token: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // weth
+      inputToken: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // weth
+      outputToken: '0x4200000000000000000000000000000000000006', // weth
       originChainId: SupportedChainId.ARBITRUM_ONE,
       destinationChainId: SupportedChainId.BASE,
       amount: 2389939424141418n,
@@ -30,7 +31,8 @@ describe('AcrossApi: Shape of API response', () => {
     // Attempt to make a REAL API call. The API implementation will assert the result shape matches the expected object
     //  Example: https://app.across.to/api/suggested-fees?token=0x82aF49447D8a07e3bd95BD0d56f35241523fBab1&originChainId=42161&destinationChainId=8453&amount=2389939424141418&recipient=0x016f34D4f2578c3e9DFfC3f2b811Ba30c0c9e7f3
     const result = await api.getSuggestedFees({
-      token: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // weth
+      inputToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // weth
+      outputToken: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270', // wpol
       originChainId: SupportedChainId.MAINNET,
       destinationChainId: SupportedChainId.POLYGON,
       amount: 1000000000000000000n,
@@ -43,10 +45,10 @@ describe('AcrossApi: Shape of API response', () => {
   it('getAvailableRoutes from ARBITRUM_ONE to BASE', async () => {
     // Attempt to make a REAL API call. The API implementation will assert the result shape matches the expected object
     const result = await api.getAvailableRoutes({
-      originChainId: SupportedChainId.ARBITRUM_ONE.toString(),
+      originChainId: SupportedChainId.ARBITRUM_ONE,
       originToken: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // weth
 
-      destinationChainId: SupportedChainId.BASE.toString(),
+      destinationChainId: SupportedChainId.BASE,
       destinationToken: '0x4200000000000000000000000000000000000006', // weth
     })
 
@@ -56,10 +58,10 @@ describe('AcrossApi: Shape of API response', () => {
   it('getAvailableRoutes from POLYGON to ARBITRUM_ONE', async () => {
     // Attempt to make a REAL API call. The API implementation will assert the result shape matches the expected object
     const result = await api.getAvailableRoutes({
-      originChainId: SupportedChainId.POLYGON.toString(),
+      originChainId: SupportedChainId.POLYGON,
       originToken: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270', // wpol
 
-      destinationChainId: SupportedChainId.ARBITRUM_ONE.toString(),
+      destinationChainId: SupportedChainId.ARBITRUM_ONE,
       destinationToken: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', // weth
     })
 

packages/bridging/src/providers/across/AcrossApi.test.ts

@@ -7,6 +7,9 @@ import { SupportedChainId } from '@cowprotocol/sdk-config'
 const mockFetch = jest.fn()
 global.fetch = mockFetch
 
+const TOKEN_A = { chainId: SupportedChainId.POLYGON, address: '0x123', decimals: 18, symbol: 'TOKEN1', name: 'Token 1' }
+const TOKEN_B = { chainId: SupportedChainId.POLYGON, address: '0x456', decimals: 6, symbol: 'TOKEN2', name: 'Token 2' }
+
 describe('AcrossApi', () => {
   let api: AcrossApi
 
@@ -36,9 +39,9 @@ describe('AcrossApi', () => {
 
     it('should fetch available routes with all parameters', async () => {
       const params = {
-        originChainId: '1',
+        originChainId: 1,
         originToken: '0x0000000000000000000000000000000000000001',
-        destinationChainId: '137',
+        destinationChainId: 137,
         destinationToken: '0x0000000000000000000000000000000000000002',
       }
 
@@ -60,9 +63,9 @@ describe('AcrossApi', () => {
 
       await expect(
         api.getAvailableRoutes({
-          originChainId: '1',
+          originChainId: 1,
           originToken: '0x0000000000000000000000000000000000000001',
-          destinationChainId: '137',
+          destinationChainId: 137,
           destinationToken: '0x0000000000000000000000000000000000000002',
         }),
       ).rejects.toThrow(BridgeQuoteErrors.API_ERROR)
@@ -71,6 +74,10 @@ describe('AcrossApi', () => {
 
   describe('getSuggestedFees', () => {
     const mockResponse: SuggestedFeesResponse = {
+      id: '1',
+      inputToken: TOKEN_A,
+      outputToken: TOKEN_B,
+      outputAmount: '300010000000',
       totalRelayFee: { pct: '100000000000000', total: '100000' },
       relayerCapitalFee: { pct: '50000000000000', total: '50000' },
       relayerGasFee: { pct: '50000000000000', total: '50000' },
@@ -101,7 +108,8 @@ describe('AcrossApi', () => {
 
     it('should fetch suggested fees with required parameters', async () => {
       const request: SuggestedFeesRequest = {
-        token: '0x0000000000000000000000000000000000000001',
+        inputToken: '0x0000000000000000000000000000000000000001',
+        outputToken: '0x0000000000000000000000000000000000000002',
         originChainId: SupportedChainId.MAINNET,
         destinationChainId: SupportedChainId.POLYGON,
         amount: 1000000000000000000n,
@@ -111,14 +119,15 @@ describe('AcrossApi', () => {
 
       expect(fees).toEqual(mockResponse)
       expect(mockFetch).toHaveBeenCalledWith(
-        `https://app.across.to/api/suggested-fees?token=${request.token}&originChainId=${request.originChainId}&destinationChainId=${request.destinationChainId}&amount=${request.amount}`,
+        `https://app.across.to/api/suggested-fees?inputToken=${request.inputToken}&outputToken=${request.outputToken}&originChainId=${request.originChainId}&destinationChainId=${request.destinationChainId}&amount=${request.amount}&allowUnmatchedDecimals=true`,
         expect.any(Object),
       )
     })
 
     it('should include recipient when provided', async () => {
       const request: SuggestedFeesRequest = {
-        token: '0x0000000000000000000000000000000000000001',
+        inputToken: '0x0000000000000000000000000000000000000001',
+        outputToken: '0x0000000000000000000000000000000000000002',
         originChainId: SupportedChainId.MAINNET,
         destinationChainId: SupportedChainId.POLYGON,
         amount: 1000000000000000000n,
@@ -142,7 +151,8 @@ describe('AcrossApi', () => {
 
       await expect(
         api.getSuggestedFees({
-          token: '0x0000000000000000000000000000000000000001',
+          inputToken: '0x0000000000000000000000000000000000000001',
+          outputToken: '0x0000000000000000000000000000000000000002',
           originChainId: SupportedChainId.MAINNET,
           destinationChainId: SupportedChainId.POLYGON,
           amount: 1000000000000000000n,
@@ -162,9 +172,9 @@ describe('AcrossApi', () => {
       })
 
       await customApi.getAvailableRoutes({
-        originChainId: '1',
+        originChainId: 1,
         originToken: '0x0000000000000000000000000000000000000001',
-        destinationChainId: '137',
+        destinationChainId: 137,
         destinationToken: '0x0000000000000000000000000000000000000002',
       })
 

packages/bridging/src/providers/across/AcrossApi.ts

@@ -1,3 +1,6 @@
+import { log } from '@cowprotocol/sdk-common'
+import { ALL_SUPPORTED_CHAINS_MAP, SupportedChainId, TokenInfo } from '@cowprotocol/sdk-config'
+
 import {
   AvailableRoutesRequest,
   DepositStatusRequest,
@@ -9,16 +12,22 @@ import {
   SuggestedFeesResponse,
 } from './types'
 import { BridgeProviderQuoteError, BridgeQuoteErrors } from '../../errors'
-import { TokenInfo } from '@cowprotocol/sdk-config'
-import { log } from '@cowprotocol/sdk-common'
 
 const ACROSS_API_URL = 'https://app.across.to/api'
 
+enum AcrossApiErrors {
+  AMOUNT_TOO_LOW = 'AMOUNT_TOO_LOW',
+}
+
+type AcrossApiToken = TokenInfo & { logoURI?: string; isNative: boolean }
+
 export interface AcrossApiOptions {
   apiBaseUrl?: string
 }
 
 export class AcrossApi {
+  private cachedTokens: TokenInfo[] = []
+
   constructor(private readonly options: AcrossApiOptions = {}) {}
 
   /**
@@ -29,19 +38,8 @@ export class AcrossApi {
    *
    * See https://docs.across.to/reference/api-reference#available-routes
    */
-  async getAvailableRoutes({
-    originChainId,
-    originToken,
-    destinationChainId,
-    destinationToken,
-  }: AvailableRoutesRequest): Promise<Route[]> {
-    const params: Record<string, string> = {}
-    if (originChainId) params.originChainId = originChainId
-    if (originToken) params.originToken = originToken
-    if (destinationChainId) params.destinationChainId = destinationChainId
-    if (destinationToken) params.destinationToken = destinationToken
-
-    return this.fetchApi('/available-routes', params, isValidRoutes)
+  async getAvailableRoutes(params: AvailableRoutesRequest): Promise<Route[]> {
+    return this.fetchApi('/available-routes', params as never as Record<string | number, string>, isValidRoutes)
   }
 
   /**
@@ -54,28 +52,34 @@ export class AcrossApi {
    */
   async getSuggestedFees(request: SuggestedFeesRequest): Promise<SuggestedFeesResponse> {
     const params: Record<string, string> = {
-      token: request.token,
+      inputToken: request.inputToken,
+      outputToken: request.outputToken,
       originChainId: request.originChainId.toString(),
       destinationChainId: request.destinationChainId.toString(),
       amount: request.amount.toString(),
+      allowUnmatchedDecimals: 'true', // Always set to true since we adjust for destination token decimals
     }
 
     if (request.recipient) {
       params.recipient = request.recipient
     }
-
-    // Get the quote from the Across API (see https://docs.across.to/reference/api-reference#suggested-fees)
-    // Example: https://app.across.to/api/suggested-fees?token=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&originChainId=8453&destinationChainId=137&amount=100000000
-    //
-    // TODO: The API documented params don't match with the example above. Ideally I would use 'inputToken' and 'outputToken', but the example above uses 'token'. This will work for current implementation, since we bridge the canonical token, but this will need to be reviewed
-    //       https://app.across.to/api/suggested-fees?inputToken=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&originChainId=8453&destinationChainId=137&outputToken=0xc2132D05D31c914a87C6611C10748AEb04B58e8F&amount=100000000
     return this.fetchApi('/suggested-fees', params, isValidSuggestedFeesResponse)
   }
 
   async getSupportedTokens(): Promise<TokenInfo[]> {
-    return this.fetchApi<(TokenInfo & { logoURI?: string })[]>('/token-list', {}).then((tokens) =>
-      tokens.map((token) => ({ ...token, logoUrl: token.logoURI })),
-    )
+    if (this.cachedTokens.length === 0) {
+      const response = await this.fetchApi<AcrossApiToken[]>('/token-list', {}).then((tokens) =>
+        tokens.map((token) => ({
+          ...token,
+          logoUrl: token.logoURI,
+          address: token.isNative
+            ? (ALL_SUPPORTED_CHAINS_MAP[token.chainId as SupportedChainId]?.nativeCurrency.address ?? token.address)
+            : token.address,
+        })),
+      )
+      this.cachedTokens = response
+    }
+    return this.cachedTokens
   }
 
   async getDepositStatus(request: DepositStatusRequest): Promise<DepositStatusResponse> {
@@ -89,7 +93,7 @@ export class AcrossApi {
 
   protected async fetchApi<T>(
     path: string,
-    params: Record<string, string>,
+    params: Record<string | number, string>,
     isValidResponse?: (response: unknown) => response is T,
   ): Promise<T> {
     const baseUrl = this.options.apiBaseUrl || ACROSS_API_URL
@@ -103,6 +107,11 @@ export class AcrossApi {
 
     if (!response.ok) {
       const errorBody = await response.json()
+
+      if (errorBody.code === AcrossApiErrors.AMOUNT_TOO_LOW) {
+        throw new BridgeProviderQuoteError(BridgeQuoteErrors.SELL_AMOUNT_TOO_SMALL, errorBody)
+      }
+
       throw new BridgeProviderQuoteError(BridgeQuoteErrors.API_ERROR, errorBody)
     }
 

packages/bridging/src/providers/across/AcrossBridgeProvider.test.ts

@@ -12,16 +12,15 @@ import { SuggestedFeesResponse } from './types'
 import { SupportedChainId, TargetChainId } from '@cowprotocol/sdk-config'
 import { setGlobalAdapter } from '@cowprotocol/sdk-common'
 import { createAdapters } from '../../../tests/setup'
-import { DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION } from '../../const'
+import { DEFAULT_EXTRA_GAS_FOR_HOOK_ESTIMATION, DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION } from '../../const'
 import stringify from 'json-stable-stringify'
 
 // Mock AcrossApi
 jest.mock('./AcrossApi')
 
-const mockTokens = [
-  { chainId: SupportedChainId.POLYGON, address: '0x123', decimals: 18, symbol: 'TOKEN1', name: 'Token 1' },
-  { chainId: SupportedChainId.POLYGON, address: '0x456', decimals: 6, symbol: 'TOKEN2', name: 'Token 2' },
-]
+const TOKEN_A = { chainId: SupportedChainId.POLYGON, address: '0x123', decimals: 18, symbol: 'TOKEN1', name: 'Token 1' }
+const TOKEN_B = { chainId: SupportedChainId.POLYGON, address: '0x456', decimals: 6, symbol: 'TOKEN2', name: 'Token 2' }
+const mockTokens = [TOKEN_A, TOKEN_B]
 
 class AcrossBridgeProviderTest extends AcrossBridgeProvider {
   constructor(options: AcrossBridgeProviderOptions) {
@@ -98,6 +97,10 @@ adapterNames.forEach((adapterName) => {
 
     describe('getQuote', () => {
       const mockSuggestedFees: SuggestedFeesResponse = {
+        id: '1',
+        inputToken: TOKEN_A,
+        outputToken: TOKEN_B,
+        outputAmount: '20000',
         totalRelayFee: { pct: '100000000000000', total: '100000' },
         relayerCapitalFee: { pct: '50000000000000', total: '50000' },
         relayerGasFee: { pct: '50000000000000', total: '50000' },
@@ -147,17 +150,18 @@ adapterNames.forEach((adapterName) => {
         expect(suggestedFees).toEqual(mockSuggestedFees)
 
         const expectedQuote: BridgeQuoteResult = {
+          id: '1',
           isSell: true,
           quoteBody: stringify(mockSuggestedFees),
           amountsAndCosts: {
-            beforeFee: { sellAmount: 1000000000000000000n, buyAmount: 1000000n },
-            afterFee: { sellAmount: 1000000000000000000n, buyAmount: 999900n },
-            afterSlippage: { sellAmount: 1000000000000000000n, buyAmount: 999900n },
+            beforeFee: { sellAmount: 1000000000000000000n, buyAmount: 20000n },
+            afterFee: { sellAmount: 1000000000000000000n, buyAmount: 19998n },
+            afterSlippage: { sellAmount: 1000000000000000000n, buyAmount: 19998n },
             costs: {
               bridgingFee: {
                 feeBps: 1,
                 amountInSellCurrency: 100000000000000n,
-                amountInBuyCurrency: 100n,
+                amountInBuyCurrency: 2n,
               },
             },
             slippageBps: 0,
@@ -200,7 +204,7 @@ adapterNames.forEach((adapterName) => {
 
     describe('getExplorerUrl', () => {
       it('should return explorer url', () => {
-        expect(provider.getExplorerUrl('123')).toEqual('https://app.across.to/transactions')
+        expect(provider.getExplorerUrl('123', '0xaaa')).toEqual('https://app.across.to/transaction/0xaaa')
       })
     })
 
@@ -262,7 +266,7 @@ adapterNames.forEach((adapterName) => {
 
         const gasLimit = await provider.getGasLimitEstimationForHook(request)
 
-        expect(gasLimit).toEqual(DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION)
+        expect(gasLimit).toEqual(DEFAULT_GAS_COST_FOR_HOOK_ESTIMATION + DEFAULT_EXTRA_GAS_FOR_HOOK_ESTIMATION)
       })
     })
   })