tapimo 0.4.4 → 0.5.1

package/src/apps/data/FundingQuoteProviders.test.ts

@@ -0,0 +1,577 @@
+import * as FundingQuotes from '../../internal/FundingQuotes.js'
+import * as FundingQuoteProviders from './FundingQuoteProviders.js'
+
+const now = () => new Date('2026-01-01T00:00:00.000Z')
+
+describe('FundingQuoteProviders', () => {
+  test('requires every Across deployment binding when any is configured', () => {
+    expect(FundingQuoteProviders.configureAcross()).toBeUndefined()
+    expect(() =>
+      FundingQuoteProviders.configureAcross({ apiKey: 'across-api-key' }),
+    ).toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderConfigurationError]`)
+    expect(
+      FundingQuoteProviders.configureAcross({
+        apiKey: 'across-api-key',
+        integratorId: '0xdead',
+        userAddress: '0x1111111111111111111111111111111111111111',
+      }),
+    ).toEqual({
+      apiKey: 'across-api-key',
+      integratorId: '0xdead',
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+  })
+
+  test('maps successful Across quotes to available quote probes', async () => {
+    const requests: RecordedRequest[] = []
+    const candidate = quoteCandidate('across')
+    const fetch = recordingFetch(requests, async () => jsonResponse(acrossQuote(candidate)))
+    const adapter = FundingQuoteProviders.across({
+      apiKey: 'across-api-key',
+      baseUrl: 'https://across.test/api/',
+      fetch,
+      integratorId: '0xdead',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    const result = await adapter.probeQuote(probeInput(candidate), new AbortController().signal)
+
+    expect(requests).toHaveLength(1)
+    expect(requests[0]?.url.pathname).toBe('/api/swap/approval')
+    expect(requests[0]?.url.searchParams.get('originChainId')).toBe('8453')
+    expect(requests[0]?.url.searchParams.get('destinationChainId')).toBe('4217')
+    expect(requests[0]?.url.searchParams.get('amount')).toBe('1000000')
+    expect(requests[0]?.url.searchParams.get('integratorId')).toBe('0xdead')
+    expect(requests[0]?.url.searchParams.get('tradeType')).toBe('exactInput')
+    expect(requests[0]?.url.searchParams.get('skipOriginTxEstimation')).toBe('true')
+    expect(requests[0]?.url.searchParams.get('strictTradeType')).toBe('true')
+    expect(requests[0]?.url.searchParams.get('depositor')).toBe(
+      '0x1111111111111111111111111111111111111111',
+    )
+    expect(requests[0]?.url.searchParams.get('recipient')).toBe(
+      '0x1111111111111111111111111111111111111111',
+    )
+    expect(new Headers(requests[0]?.init?.headers).get('authorization')).toBe(
+      'Bearer across-api-key',
+    )
+    expect(result).toMatchObject({
+      expiresAt: '2026-01-01T00:01:00.000Z',
+      minimumOutputAmount: '988000',
+      outputAmount: '990000',
+      outputAmountFormatted: '0.99',
+      quality: {
+        estimatedSeconds: 2,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'across:swap-approval',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'available',
+    })
+  })
+
+  test('maps recognized Across quote errors to unavailable probes', async () => {
+    const candidate = quoteCandidate('across')
+    const fetch = recordingFetch([], async () => jsonResponse({ code: 'NO_ROUTE' }, 400))
+    const adapter = FundingQuoteProviders.across({
+      apiKey: 'across-api-key',
+      fetch,
+      integratorId: '0xdead',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).resolves.toMatchObject({
+      quality: {
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'across:swap-approval:NO_ROUTE',
+        tier: 'unavailable',
+      },
+      status: 'unavailable',
+    })
+  })
+
+  test('rejects malformed Across quote payloads', async () => {
+    const candidate = quoteCandidate('across')
+    const fetch = recordingFetch([], async () =>
+      jsonResponse({ ...acrossQuote(candidate), expectedOutputAmount: '0' }),
+    )
+    const adapter = FundingQuoteProviders.across({
+      apiKey: 'across-api-key',
+      fetch,
+      integratorId: '0xdead',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
+  })
+
+  test('rejects invalid Across configuration', () => {
+    expect(() =>
+      FundingQuoteProviders.across({
+        apiKey: 'across-api-key',
+        integratorId: 'tempo',
+        userAddress: '0x1111111111111111111111111111111111111111',
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderConfigurationError]`)
+  })
+
+  test('maps successful Relay quotes to available quote probes', async () => {
+    const requests: RecordedRequest[] = []
+    const candidate = quoteCandidate()
+    const fetch = recordingFetch(requests, async () =>
+      jsonResponse({
+        details: {
+          currencyOut: {
+            amount: '990000',
+            minimumAmount: '980000',
+          },
+          timeEstimate: 15,
+          totalImpact: { percent: '-1.20' },
+        },
+      }),
+    )
+    const adapter = FundingQuoteProviders.relay({
+      apiKey: 'relay-api-key',
+      fetch,
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    const result = await adapter.probeQuote(probeInput(candidate), new AbortController().signal)
+
+    expect(requests.map((request) => request.url.pathname)).toEqual(['/quote/v2'])
+    expect(new Headers(requests[0]?.init?.headers).get('x-api-key')).toBe('relay-api-key')
+    expect(jsonRequestBody(requests[0])).toMatchObject({
+      amount: '1000000',
+      destinationChainId: 4217,
+      destinationCurrency: candidate.destinationToken.address,
+      originChainId: 8453,
+      originCurrency: candidate.sourceToken.address,
+      tradeType: 'EXACT_INPUT',
+      user: '0x1111111111111111111111111111111111111111',
+    })
+    expect(result).toMatchObject({
+      minimumOutputAmount: '980000',
+      outputAmount: '990000',
+      outputAmountFormatted: '0.99',
+      quality: {
+        estimatedSeconds: 15,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'relay:quote-v2',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'available',
+    })
+  })
+
+  test('maps successful Rhino quotes to available quote probes', async () => {
+    const requests: RecordedRequest[] = []
+    const candidate = quoteCandidate('rhino')
+    const fetch = recordingFetch(requests, async () =>
+      jsonResponse({
+        _tag: 'bridge',
+        chainIn: 'BASE',
+        chainOut: 'TEMPO',
+        estimatedDuration: 1_500,
+        payAmount: '1.0000000',
+        receiveAmount: '0.9830000',
+        token: 'USDC',
+      }),
+    )
+    const adapter = FundingQuoteProviders.rhino({
+      baseUrl: 'https://rhino.test/bridge/',
+      fetch,
+      now,
+    })
+
+    const result = await adapter.probeQuote(probeInput(candidate), new AbortController().signal)
+
+    expect(requests).toHaveLength(1)
+    expect(requests[0]?.url.pathname).toBe('/bridge/quote/bridge-swap/public')
+    expect(Object.fromEntries(requests[0]!.url.searchParams)).toEqual({
+      amount: '1',
+      amountNative: '0',
+      chainIn: 'BASE',
+      chainOut: 'TEMPO',
+      mode: 'pay',
+      tokenIn: 'USDC',
+      tokenOut: 'USDC',
+    })
+    expect(result).toEqual({
+      outputAmount: '983000',
+      outputAmountFormatted: '0.983',
+      quality: {
+        estimatedSeconds: 2,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'rhino:bridge-swap-public',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'available',
+    })
+  })
+
+  test('maps unavailable Rhino routes to unavailable quote probes', async () => {
+    const candidate = quoteCandidate('rhino')
+    const adapter = FundingQuoteProviders.rhino({
+      fetch: recordingFetch([], async () => jsonResponse({ _tag: 'NoRouteFoundError' }, 404)),
+      now,
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).resolves.toMatchObject({
+      quality: {
+        sourceDetail: 'rhino:bridge-swap-public:NoRouteFoundError',
+        tier: 'unavailable',
+      },
+      status: 'unavailable',
+    })
+  })
+
+  test('maps Solana and Tron identifiers into Rhino quote requests', async () => {
+    const cases = [
+      {
+        candidate: quoteCandidate('rhino', { sourceChain: 'solana' }),
+        chainIn: 'SOLANA',
+        tokenOut: 'USDC',
+      },
+      {
+        candidate: quoteCandidate('rhino', {
+          destinationToken: 'USDT0',
+          sourceChain: 'tron',
+          sourceToken: 'USDT',
+        }),
+        chainIn: 'TRON',
+        tokenOut: 'USDT',
+      },
+    ] as const
+
+    for (const testCase of cases) {
+      const requests: RecordedRequest[] = []
+      const adapter = FundingQuoteProviders.rhino({
+        fetch: recordingFetch(requests, async () =>
+          jsonResponse({
+            _tag: 'bridge',
+            chainIn: testCase.chainIn,
+            chainOut: 'TEMPO',
+            payAmount: '1',
+            receiveAmount: '0.983',
+            token: testCase.tokenOut,
+          }),
+        ),
+        now,
+      })
+
+      await expect(
+        adapter.probeQuote(probeInput(testCase.candidate), new AbortController().signal),
+      ).resolves.toMatchObject({ outputAmount: '983000', status: 'available' })
+      expect(requests[0]?.url.searchParams.get('chainIn')).toBe(testCase.chainIn)
+      expect(requests[0]?.url.searchParams.get('tokenOut')).toBe(testCase.tokenOut)
+    }
+  })
+
+  test('surfaces Rhino request decoding failures', async () => {
+    const candidate = quoteCandidate('rhino')
+    const adapter = FundingQuoteProviders.rhino({
+      fetch: recordingFetch([], async () => jsonResponse({ _tag: 'HttpApiDecodeError' }, 400)),
+      now,
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[FundingQuoteProviders.ProviderResponseError: Provider request failed with status 400]`,
+    )
+  })
+
+  test('surfaces unrecognized Rhino route errors', async () => {
+    const candidate = quoteCandidate('rhino')
+    const failures = [
+      { body: null, status: 404 },
+      { body: { _tag: 'InvalidRequest' }, status: 422 },
+    ] as const
+
+    for (const failure of failures) {
+      const adapter = FundingQuoteProviders.rhino({
+        fetch: recordingFetch([], async () => jsonResponse(failure.body, failure.status)),
+        now,
+      })
+      const cause = await adapter
+        .probeQuote(probeInput(candidate), new AbortController().signal)
+        .catch((error: unknown) => error)
+      expect(cause).toMatchObject({
+        name: 'FundingQuoteProviders.ProviderResponseError',
+        status: failure.status,
+      })
+    }
+  })
+
+  test('rejects mismatched Rhino quote payloads', async () => {
+    const candidate = quoteCandidate('rhino')
+    const adapter = FundingQuoteProviders.rhino({
+      fetch: recordingFetch([], async () =>
+        jsonResponse({
+          _tag: 'bridge',
+          chainIn: 'SOLANA',
+          chainOut: 'TEMPO',
+          payAmount: '1',
+          receiveAmount: '0.983',
+          token: 'USDC',
+        }),
+      ),
+      now,
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
+  })
+
+  test('rejects non-representable Rhino output precision', async () => {
+    const candidate = quoteCandidate('rhino')
+    const adapter = FundingQuoteProviders.rhino({
+      fetch: recordingFetch([], async () =>
+        jsonResponse({
+          _tag: 'bridge',
+          chainIn: 'BASE',
+          chainOut: 'TEMPO',
+          payAmount: '1',
+          receiveAmount: '0.9830001',
+          token: 'USDC',
+        }),
+      ),
+      now,
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
+  })
+
+  test('calls the runtime fetch method with its global receiver', async () => {
+    const candidate = quoteCandidate()
+    const fetch = vi.fn(function (this: unknown) {
+      expect(this).toBe(globalThis)
+      return Promise.resolve(
+        jsonResponse({
+          details: {
+            currencyOut: { amount: '990000', minimumAmount: '980000' },
+            timeEstimate: 15,
+          },
+        }),
+      )
+    })
+    vi.stubGlobal('fetch', fetch)
+
+    try {
+      const adapter = FundingQuoteProviders.relay({
+        now,
+        userAddress: '0x1111111111111111111111111111111111111111',
+      })
+      const result = await adapter.probeQuote(probeInput(candidate), new AbortController().signal)
+
+      expect(result.outputAmount).toBe('990000')
+      expect(fetch).toHaveBeenCalledTimes(1)
+    } finally {
+      vi.unstubAllGlobals()
+    }
+  })
+
+  const invalidAcrossQuotes = [
+    [
+      'mismatched input amounts',
+      (body: ReturnType<typeof acrossQuote>) => (body.inputAmount = '1'),
+    ],
+    [
+      'mismatched token addresses',
+      (body: ReturnType<typeof acrossQuote>) =>
+        (body.inputToken.address = '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2'),
+    ],
+    [
+      'mismatched token chains',
+      (body: ReturnType<typeof acrossQuote>) => (body.inputToken.chainId = 1),
+    ],
+    [
+      'mismatched token decimals',
+      (body: ReturnType<typeof acrossQuote>) => (body.inputToken.decimals = 18),
+    ],
+    [
+      'expired quotes',
+      (body: ReturnType<typeof acrossQuote>) => (body.quoteExpiryTimestamp = 1767225600),
+    ],
+    [
+      'out-of-range expiries',
+      (body: ReturnType<typeof acrossQuote>) =>
+        (body.quoteExpiryTimestamp = Number.MAX_SAFE_INTEGER),
+    ],
+    [
+      'invalid output bounds',
+      (body: ReturnType<typeof acrossQuote>) => (body.minOutputAmount = '990001'),
+    ],
+  ] as const
+
+  for (const [name, mutate] of invalidAcrossQuotes)
+    test(`rejects Across quotes with ${name}`, async () => {
+      const candidate = quoteCandidate('across')
+      const body = acrossQuote(candidate)
+      mutate(body)
+      const adapter = FundingQuoteProviders.across({
+        apiKey: 'across-api-key',
+        fetch: recordingFetch([], async () => jsonResponse(body)),
+        integratorId: '0xdead',
+        now,
+        userAddress: '0x1111111111111111111111111111111111111111',
+      })
+
+      await expect(
+        adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderPayloadError]`)
+    })
+
+  test('returns bounded Across failure diagnostics', async () => {
+    const candidate = quoteCandidate('across')
+    const adapter = FundingQuoteProviders.across({
+      apiKey: 'across-api-key',
+      fetch: recordingFetch([], async () =>
+        jsonResponse({ apiKey: 'secret', code: 'UNAUTHORIZED' }, 401),
+      ),
+      integratorId: '0xdead',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+    const cause = await adapter
+      .probeQuote(probeInput(candidate), new AbortController().signal)
+      .catch((error: unknown) => error)
+
+    expect(FundingQuoteProviders.providerFailure({ cause, provider: 'across' })).toEqual({
+      code: 'UNAUTHORIZED',
+      failure: 'http',
+      id: 'across',
+      operation: 'swap/approval',
+      status: 401,
+    })
+  })
+
+  test('returns explicit timeout failure diagnostics', () => {
+    expect(
+      FundingQuoteProviders.providerFailure({
+        cause: new FundingQuotes.ProviderAdapterTimeoutError(),
+        provider: 'across',
+      }),
+    ).toEqual({
+      failure: 'timeout',
+      id: 'across',
+      operation: 'swap/approval',
+    })
+  })
+})
+
+type RecordedRequest = {
+  init: RequestInit | undefined
+  url: URL
+}
+
+function quoteCandidate(
+  provider: FundingQuotes.ProviderId = 'relay',
+  options: quoteCandidate.Options = {},
+): FundingQuotes.QuoteProbeInput['candidate'] {
+  const [candidate] = FundingQuotes.listQuoteCandidates({
+    destinationToken: options.destinationToken,
+    provider,
+    sourceAmount: '1000000',
+    sourceAmountUnits: 'baseUnits',
+    sourceChain: options.sourceChain ?? 'base',
+    sourceToken: options.sourceToken ?? 'USDC',
+  })
+  if (!candidate) throw new Error(`Missing ${provider} quote candidate`)
+  return candidate
+}
+
+declare namespace quoteCandidate {
+  type Options = {
+    destinationToken?: string | undefined
+    sourceChain?: string | undefined
+    sourceToken?: string | undefined
+  }
+}
+
+function acrossQuote(candidate: FundingQuotes.QuoteProbeInput['candidate']) {
+  return {
+    amountType: 'exactInput',
+    expectedFillTime: 2,
+    expectedOutputAmount: '990000',
+    inputAmount: candidate.sourceAmount.amount,
+    inputToken: {
+      address: candidate.sourceToken.address,
+      chainId: 8453,
+      decimals: candidate.sourceToken.decimals,
+      symbol: candidate.sourceToken.symbol,
+    },
+    minOutputAmount: '988000',
+    outputToken: {
+      address: candidate.destinationToken.address,
+      chainId: 4217,
+      decimals: candidate.destinationToken.decimals,
+      symbol: candidate.destinationToken.symbol,
+    },
+    quoteExpiryTimestamp: 1767225660,
+  }
+}
+
+function probeInput(
+  candidate: FundingQuotes.QuoteProbeInput['candidate'],
+): FundingQuotes.QuoteProbeInput {
+  return {
+    candidate,
+    cache: { bypass: false },
+    destinationChain: candidate.destinationChain,
+    destinationToken: candidate.destinationToken,
+    request: {
+      provider: candidate.provider.id,
+      sourceAmount: candidate.sourceAmount.amount,
+      sourceAmountUnits: 'baseUnits',
+      sourceChain: candidate.sourceChain.id,
+      sourceToken: candidate.sourceToken.symbol,
+    },
+    sourceAmount: candidate.sourceAmount,
+    sourceChain: candidate.sourceChain,
+    sourceToken: candidate.sourceToken,
+  }
+}
+
+function recordingFetch(
+  requests: RecordedRequest[],
+  respond: (request: RecordedRequest) => Response | Promise<Response>,
+): typeof globalThis.fetch {
+  return async (input, init) => {
+    const request = { init, url: toUrl(input) }
+    requests.push(request)
+    return respond(request)
+  }
+}
+
+function toUrl(input: Parameters<typeof globalThis.fetch>[0]) {
+  if (input instanceof Request) return new URL(input.url)
+  return new URL(String(input))
+}
+
+function jsonResponse(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), {
+    headers: { 'content-type': 'application/json' },
+    status,
+  })
+}
+
+function jsonRequestBody(request: RecordedRequest | undefined) {
+  if (typeof request?.init?.body !== 'string') throw new Error('Expected JSON request body')
+  return JSON.parse(request.init.body) as unknown
+}