tapimo 0.5.0 → 0.5.2

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

@@ -4,6 +4,140 @@ 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('requires every Squid deployment binding when any is configured', () => {
+    expect(FundingQuoteProviders.configureSquid()).toBeUndefined()
+    expect(() =>
+      FundingQuoteProviders.configureSquid({ integratorId: 'squid-integrator-id' }),
+    ).toThrowErrorMatchingInlineSnapshot(`[FundingQuoteProviders.ProviderConfigurationError]`)
+    expect(
+      FundingQuoteProviders.configureSquid({
+        integratorId: 'squid-integrator-id',
+        userAddress: '0x1111111111111111111111111111111111111111',
+      }),
+    ).toEqual({
+      integratorId: 'squid-integrator-id',
+      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()
@@ -54,6 +188,265 @@ describe('FundingQuoteProviders', () => {
     })
   })
 
+  test('maps successful Squid quotes to available quote probes', async () => {
+    const requests: RecordedRequest[] = []
+    const candidate = quoteCandidate('squid')
+    const fetch = recordingFetch(requests, async () => jsonResponse(squidQuote(candidate)))
+    const adapter = FundingQuoteProviders.squid({
+      baseUrl: 'https://squid.test/v2/',
+      fetch,
+      integratorId: 'squid-integrator-id',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    const result = await adapter.probeQuote(probeInput(candidate), new AbortController().signal)
+
+    expect(requests).toHaveLength(1)
+    expect(requests[0]?.url.pathname).toBe('/v2/route')
+    expect(new Headers(requests[0]?.init?.headers).get('x-integrator-id')).toBe(
+      'squid-integrator-id',
+    )
+    expect(jsonRequestBody(requests[0])).toEqual({
+      fromAddress: '0x1111111111111111111111111111111111111111',
+      fromAmount: '1000000',
+      fromChain: '8453',
+      fromToken: candidate.sourceToken.address,
+      quoteOnly: true,
+      slippage: 1,
+      toAddress: '0x1111111111111111111111111111111111111111',
+      toChain: '4217',
+      toToken: candidate.destinationToken.address,
+    })
+    expect(result).toEqual({
+      minimumOutputAmount: '989622',
+      outputAmount: '999620',
+      outputAmountFormatted: '0.99962',
+      quality: {
+        estimatedSeconds: 10,
+        liquiditySource: 'providerQuote',
+        sourceDetail: 'squid:route-v2',
+        tier: 'liquid',
+      },
+      sampledAt: '2026-01-01T00:00:00.000Z',
+      status: 'available',
+    })
+  })
+
+  test('maps unavailable Squid routes to unavailable quote probes', async () => {
+    const candidate = quoteCandidate('squid')
+    const adapter = FundingQuoteProviders.squid({
+      fetch: recordingFetch([], async () =>
+        jsonResponse(
+          {
+            message: 'Please increase the swap amount and try again.',
+            statusCode: 400,
+            type: 'BAD_REQUEST',
+          },
+          400,
+        ),
+      ),
+      integratorId: 'squid-integrator-id',
+      now,
+      userAddress: '0x1111111111111111111111111111111111111111',
+    })
+
+    await expect(
+      adapter.probeQuote(probeInput(candidate), new AbortController().signal),
+    ).resolves.toMatchObject({
+      quality: {
+        sourceDetail: 'squid:route-v2:AMOUNT_TOO_LOW',
+        tier: 'unavailable',
+      },
+      status: 'unavailable',
+    })
+  })
+
+  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) {
@@ -82,6 +475,165 @@ describe('FundingQuoteProviders', () => {
       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]`)
+    })
+
+  const invalidSquidQuotes = [
+    [
+      'mismatched input amounts',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.fromAmount = '1'),
+    ],
+    [
+      'mismatched input token addresses',
+      (body: ReturnType<typeof squidQuote>) =>
+        (body.route.estimate.fromToken.address = '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2'),
+    ],
+    [
+      'mismatched input chains',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.fromToken.chainId = 1),
+    ],
+    [
+      'mismatched input decimals',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.fromToken.decimals = 18),
+    ],
+    [
+      'mismatched output token addresses',
+      (body: ReturnType<typeof squidQuote>) =>
+        (body.route.estimate.toToken.address = '0x20c00000000000000000000014f22ca97301eb73'),
+    ],
+    [
+      'mismatched output chains',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.toToken.chainId = '1'),
+    ],
+    [
+      'mismatched output decimals',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.toToken.decimals = 18 as never),
+    ],
+    [
+      'zero output amounts',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.toAmount = '0'),
+    ],
+    [
+      'invalid output bounds',
+      (body: ReturnType<typeof squidQuote>) => (body.route.estimate.toAmountMin = '1000000'),
+    ],
+  ] as const
+
+  for (const [name, mutate] of invalidSquidQuotes)
+    test(`rejects Squid quotes with ${name}`, async () => {
+      const candidate = quoteCandidate('squid')
+      const body = squidQuote(candidate)
+      mutate(body)
+      const adapter = FundingQuoteProviders.squid({
+        fetch: recordingFetch([], async () => jsonResponse(body)),
+        integratorId: 'squid-integrator-id',
+        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',
+    })
+  })
+
+  test('returns bounded Squid failure diagnostics', () => {
+    expect(
+      FundingQuoteProviders.providerFailure({
+        cause: new TypeError('network failure'),
+        provider: 'squid',
+      }),
+    ).toEqual({
+      failure: 'network',
+      id: 'squid',
+      operation: 'v2/route',
+    })
+  })
 })
 
 type RecordedRequest = {
@@ -89,18 +641,76 @@ type RecordedRequest = {
   url: URL
 }
 
-function quoteCandidate(): FundingQuotes.QuoteProbeInput['candidate'] {
+function quoteCandidate(
+  provider: FundingQuotes.ProviderId = 'relay',
+  options: quoteCandidate.Options = {},
+): FundingQuotes.QuoteProbeInput['candidate'] {
   const [candidate] = FundingQuotes.listQuoteCandidates({
-    provider: 'relay',
+    destinationToken: options.destinationToken,
+    provider,
     sourceAmount: '1000000',
     sourceAmountUnits: 'baseUnits',
-    sourceToken: 'USDC',
-    sourceChain: 'base',
+    sourceChain: options.sourceChain ?? 'base',
+    sourceToken: options.sourceToken ?? 'USDC',
   })
-  if (!candidate) throw new Error('Missing Relay quote candidate')
+  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 squidQuote(candidate: FundingQuotes.QuoteProbeInput['candidate']) {
+  return {
+    route: {
+      estimate: {
+        estimatedRouteDuration: 10,
+        fromAmount: candidate.sourceAmount.amount,
+        fromToken: {
+          address: candidate.sourceToken.address,
+          chainId: 8453,
+          decimals: candidate.sourceToken.decimals,
+        },
+        toAmount: '999620',
+        toAmountMin: '989622',
+        toToken: {
+          address: candidate.destinationToken.address,
+          chainId: '4217',
+          decimals: candidate.destinationToken.decimals,
+        },
+      },
+    },
+  }
+}
+
 function probeInput(
   candidate: FundingQuotes.QuoteProbeInput['candidate'],
 ): FundingQuotes.QuoteProbeInput {