add: configure uniswap's getRouteStatus to get the response from across so we know the receiving txnId

Oxbobby · Oxbobby · commit e3fe03de22b0 · 2026-05-31T22:31:15.000+03:00
diff --git a/src/interfaces/swapAndBridge.ts b/src/interfaces/swapAndBridge.ts
@@ -120,6 +120,9 @@ export interface UniswapQuote {
   slippage?: number
   routeString?: string
   estimatedFillTimeMs?: number
+  exclusiveRelayer?: string
+  exclusivityDeadline?: number
+  fillDeadline?: number
   aggregatedOutputs?: {
     amount: string
     token: string
diff --git a/src/services/across/api.test.ts b/src/services/across/api.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it, jest } from '@jest/globals'
+
+import { AcrossAPI } from './api'
+
+const makeResponse = (body: any, ok = true, status = ok ? 200 : 400) => ({
+  ok,
+  status,
+  json: async () => body
+})
+
+const txHash = '0x1111111111111111111111111111111111111111111111111111111111111111'
+const fillTxnRef = '0x2222222222222222222222222222222222222222222222222222222222222222'
+const depositRefundTxnRef = '0x3333333333333333333333333333333333333333333333333333333333333333'
+
+describe('AcrossAPI', () => {
+  it('returns the fill transaction id for completed bridges', async () => {
+    const fetch = jest.fn(async () => makeResponse({ status: 'filled', fillTxnRef }))
+    const acrossApi = new AcrossAPI({ fetch: fetch as any })
+
+    await expect(acrossApi.getRouteStatus({ txHash })).resolves.toEqual({
+      status: 'completed',
+      txnId: fillTxnRef
+    })
+    expect(fetch).toHaveBeenCalledWith(
+      `https://app.across.to/api/deposit/status?depositTxnRef=${txHash}`
+    )
+  })
+
+  it('returns the refund transaction id for refunded bridges', async () => {
+    const fetch = jest.fn(async () => makeResponse({ status: 'refunded', depositRefundTxnRef }))
+    const acrossApi = new AcrossAPI({ fetch: fetch as any })
+
+    await expect(acrossApi.getRouteStatus({ txHash })).resolves.toEqual({
+      status: 'refunded',
+      txnId: depositRefundTxnRef
+    })
+  })
+
+  it('keeps polling expired bridges until the refund transaction is available', async () => {
+    const fetch = jest.fn(async () => makeResponse({ status: 'expired' }))
+    const acrossApi = new AcrossAPI({ fetch: fetch as any })
+
+    await expect(acrossApi.getRouteStatus({ txHash })).resolves.toEqual({ status: null })
+  })
+
+  it('keeps polling while Across indexes the deposit', async () => {
+    const fetch = jest.fn(async () =>
+      makeResponse(
+        {
+          error: 'DepositNotFoundException',
+          message: 'Deposit not found given the provided constraints'
+        },
+        false,
+        404
+      )
+    )
+    const acrossApi = new AcrossAPI({ fetch: fetch as any })
+
+    await expect(acrossApi.getRouteStatus({ txHash })).resolves.toEqual({ status: null })
+  })
+})
diff --git a/src/services/across/api.ts b/src/services/across/api.ts
@@ -0,0 +1,94 @@
+import SwapAndBridgeProviderApiError from '../../classes/SwapAndBridgeProviderApiError'
+import { CustomResponse, Fetch } from '../../interfaces/fetch'
+import { SwapAndBridgeRouteStatusResult } from '../../interfaces/swapAndBridge'
+import { ACROSS_API_BASE_URL } from './constants'
+
+interface AcrossDepositStatusResponse {
+  status: 'filled' | 'pending' | 'expired' | 'refunded'
+  fillTxnRef?: string | null
+  depositRefundTxnRef?: string | null
+}
+
+interface AcrossDepositStatusErrorResponse {
+  error: string
+  message: string
+}
+
+const isAcrossDepositNotFound = (
+  response: AcrossDepositStatusResponse | AcrossDepositStatusErrorResponse
+): response is AcrossDepositStatusErrorResponse =>
+  'error' in response && response.error === 'DepositNotFoundException'
+
+export class AcrossAPI {
+  #fetch: Fetch
+
+  #requestTimeoutMs = 15000
+
+  constructor({ fetch }: { fetch: Fetch }) {
+    this.#fetch = fetch
+  }
+
+  async getRouteStatus({ txHash }: { txHash: string }): Promise<SwapAndBridgeRouteStatusResult> {
+    const params = new URLSearchParams({
+      depositTxnRef: txHash
+    })
+
+    let response: CustomResponse
+    let timeoutPromise: NodeJS.Timeout | undefined
+
+    try {
+      response = await Promise.race([
+        this.#fetch(`${ACROSS_API_BASE_URL}/deposit/status?${params.toString()}`),
+        new Promise<CustomResponse>((_, reject) => {
+          timeoutPromise = setTimeout(() => {
+            reject(
+              new SwapAndBridgeProviderApiError(
+                'Our service provider Across is temporarily unavailable or your internet connection is too slow.'
+              )
+            )
+          }, this.#requestTimeoutMs)
+        })
+      ])
+    } catch (e: any) {
+      if (e instanceof SwapAndBridgeProviderApiError) throw e
+
+      const message = e?.message || 'no message'
+      const status = e?.status ? `, status: <${e.status}>` : ''
+      throw new SwapAndBridgeProviderApiError(
+        `Unable to get the route status. Please check back later to proceed. Our service provider Across could not be reached: <${message}>${status}`
+      )
+    } finally {
+      if (timeoutPromise) clearTimeout(timeoutPromise)
+    }
+
+    let responseBody: AcrossDepositStatusResponse | AcrossDepositStatusErrorResponse
+    try {
+      responseBody = await response.json()
+    } catch (e: any) {
+      const message = e?.message || 'no message'
+      throw new SwapAndBridgeProviderApiError(
+        `Unable to get the route status. Please check back later to proceed. Error details: <Unexpected non-JSON response from our service provider Across>, message: <${message}>`
+      )
+    }
+
+    if (!response.ok && !isAcrossDepositNotFound(responseBody)) {
+      const upstreamMessage =
+        'message' in responseBody
+          ? responseBody.message
+          : JSON.stringify(responseBody).slice(0, 250)
+      throw new SwapAndBridgeProviderApiError(
+        `Unable to get the route status. Please check back later to proceed. Our service provider Across responded: <${upstreamMessage}>`
+      )
+    }
+
+    if (isAcrossDepositNotFound(responseBody)) return { status: null }
+    if (responseBody.status === 'filled' && responseBody.fillTxnRef) {
+      return { status: 'completed', txnId: responseBody.fillTxnRef }
+    }
+    if (responseBody.status === 'refunded' && responseBody.depositRefundTxnRef) {
+      return { status: 'refunded', txnId: responseBody.depositRefundTxnRef }
+    }
+
+    return { status: null }
+  }
+}
diff --git a/src/services/across/constants.ts b/src/services/across/constants.ts
@@ -0,0 +1 @@
+export const ACROSS_API_BASE_URL = 'https://app.across.to/api'
diff --git a/src/services/uniswap/api.test.ts b/src/services/uniswap/api.test.ts
@@ -110,6 +110,61 @@ describe('UniswapAPI', () => {
     expect(quote.routes[0]!.steps[0]!.minAmountOut).toBe('994000')
   })
 
+  it('tags Across bridge quotes so status polling uses the Across API', async () => {
+    const fetch = jest.fn(async () =>
+      makeResponse({
+        requestId: 'request-id',
+        routing: 'BRIDGE',
+        quote: {
+          chainId: 1,
+          destinationChainId: 8453,
+          input: { amount: '1000000', token: tokenIn },
+          output: { amount: '999000', token: tokenIn, recipient: userAddress },
+          swapper: userAddress,
+          tradeType: 'EXACT_INPUT',
+          quoteId: 'quote-id',
+          exclusiveRelayer: '0x1111111111111111111111111111111111111111',
+          exclusivityDeadline: 100,
+          fillDeadline: 200
+        }
+      })
+    )
+    const uniswapApi = new UniswapAPI({ fetch: fetch as any, apiKey: 'test-key' })
+
+    const quote = await uniswapApi.quote({
+      fromAsset: {
+        address: tokenIn,
+        amount: 1000000n,
+        chainId: 1n,
+        decimals: 6,
+        flags: { canTopUpGasTank: false, isFeeToken: false, onGasTank: false, rewardsType: null },
+        marketDataIn: [],
+        name: 'USDC',
+        priceIn: [{ baseCurrency: 'usd', price: 1 }],
+        symbol: 'USDC'
+      } as any,
+      fromChainId: 1,
+      fromTokenAddress: tokenIn,
+      toAsset: {
+        address: tokenIn,
+        chainId: 8453,
+        decimals: 6,
+        name: 'USDC',
+        symbol: 'USDC'
+      },
+      toChainId: 8453,
+      toTokenAddress: tokenIn,
+      fromAmount: 1000000n,
+      userAddress,
+      sort: 'output',
+      isWrapOrUnwrap: false,
+      accountNativeBalance: 1n,
+      nativeSymbol: 'ETH'
+    })
+
+    expect(quote.routes[0]!.usedBridgeNames).toEqual(['across'])
+  })
+
   it('builds swap calldata and parses the approval spender', async () => {
     const spender = '0x1111111111111111111111111111111111111111'
     const fetch = (jest.fn() as any)
@@ -224,4 +279,49 @@ describe('UniswapAPI', () => {
     expect(fetch).toHaveBeenCalledTimes(1)
     expect(tx.approvalData).toBe(null)
   })
+
+  describe('getRouteStatus', () => {
+    const txHash = '0x1111111111111111111111111111111111111111111111111111111111111111'
+    const fillTxnRef = '0x2222222222222222222222222222222222222222222222222222222222222222'
+
+    it('returns the source transaction id for same-chain swaps', async () => {
+      const fetch = jest.fn()
+      const uniswapApi = new UniswapAPI({ fetch: fetch as any, apiKey: 'test-key' })
+
+      await expect(
+        uniswapApi.getRouteStatus({ txHash, fromChainId: 1, toChainId: 1 })
+      ).resolves.toEqual({ status: 'completed', txnId: txHash })
+      expect(fetch).not.toHaveBeenCalled()
+    })
+
+    it('delegates Across bridge status checks to the Across API', async () => {
+      const fetch = jest.fn(async () => makeResponse({ status: 'filled', fillTxnRef }))
+      const uniswapApi = new UniswapAPI({ fetch: fetch as any, apiKey: 'test-key' })
+
+      await expect(
+        uniswapApi.getRouteStatus({ txHash, fromChainId: 1, toChainId: 8453, bridge: 'across' })
+      ).resolves.toEqual({ status: 'completed', txnId: fillTxnRef })
+      expect(fetch).toHaveBeenCalledWith(
+        `https://app.across.to/api/deposit/status?depositTxnRef=${txHash}`
+      )
+    })
+
+    it('uses the Uniswap status API for non-Across bridges', async () => {
+      const fetch = jest.fn(async () =>
+        makeResponse({
+          requestId: 'request-id',
+          swaps: [{ swapType: 'BRIDGE', status: 'SUCCESS', txHash: fillTxnRef }]
+        })
+      )
+      const uniswapApi = new UniswapAPI({ fetch: fetch as any, apiKey: 'test-key' })
+
+      await expect(
+        uniswapApi.getRouteStatus({ txHash, fromChainId: 1, toChainId: 8453 })
+      ).resolves.toEqual({ status: 'completed', txnId: fillTxnRef })
+      expect(fetch).toHaveBeenCalledWith(
+        `https://trade-api.gateway.uniswap.org/v1/swaps?txHashes=${txHash}&chainId=1`,
+        { headers: expect.any(Object) }
+      )
+    })
+  })
 })
diff --git a/src/services/uniswap/api.ts b/src/services/uniswap/api.ts
@@ -31,6 +31,7 @@ import {
   isNoFeeToken,
   sortNativeTokenFirst
 } from '../../libs/swapAndBridge/swapAndBridge'
+import { AcrossAPI } from '../across/api'
 import {
   AMBIRE_FEE_TAKER_ADDRESS,
   FEE_PERCENT,
@@ -42,6 +43,11 @@ import {
 
 const erc20Interface = new Interface(ERC20.abi)
 
+const isAcrossBridgeQuote = (quote: UniswapQuote) =>
+  quote.exclusiveRelayer !== undefined &&
+  quote.exclusivityDeadline !== undefined &&
+  quote.fillDeadline !== undefined
+
 const normalizeAddress = (address: string) =>
   address.toLowerCase() === ZeroAddress.toLowerCase() ? ZeroAddress : getAddress(address)
 
@@ -191,7 +197,9 @@ const normalizeUniswapRouteToSwapAndBridgeRoute = ({
     fromAmount,
     toAmount,
     currentUserTxIndex: 0,
-    ...(fromChainId === toChainId ? { usedDexName: 'Uniswap' } : { usedBridgeNames: ['uniswap'] }),
+    ...(fromChainId === toChainId
+      ? { usedDexName: 'Uniswap' }
+      : { usedBridgeNames: [isAcrossBridgeQuote(quote) ? 'across' : 'uniswap'] }),
     userTxs: [userTx],
     steps: [step],
     inputValueInUsd,
@@ -233,6 +241,8 @@ export class UniswapAPI implements SwapProvider {
 
   #fetch: Fetch
 
+  #acrossAPI: AcrossAPI
+
   #headers: RequestInitWithCustomHeaders['headers']
 
   #requestTimeoutMs = 15000
@@ -243,6 +253,7 @@ export class UniswapAPI implements SwapProvider {
 
   constructor({ fetch, apiKey }: { fetch: Fetch; apiKey: string }) {
     this.#fetch = fetch
+    this.#acrossAPI = new AcrossAPI({ fetch })
     this.#headers = {
       Accept: 'application/json',
       'Content-Type': 'application/json',
@@ -574,16 +585,15 @@ export class UniswapAPI implements SwapProvider {
     txHash,
     fromChainId,
     toChainId,
-    requestId,
-    routeId
+    bridge
   }: {
     txHash: string
     fromChainId: number
     toChainId: number
-    requestId?: string
-    routeId?: string
+    bridge?: string
   }): Promise<SwapAndBridgeRouteStatusResult> {
     if (fromChainId === toChainId) return { status: 'completed', txnId: txHash }
+    if (bridge === 'across') return this.#acrossAPI.getRouteStatus({ txHash })
 
     this.#ensureApiKey()
 

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+export const ACROSS_API_BASE_URL = 'https://app.across.to/api'`