tapimo 0.7.0 → 0.7.2

package/src/internal/FundingQuotes.test.ts

@@ -1,456 +0,0 @@
-import * as FundingQuotes from './FundingQuotes.js'
-
-const baseUsdcRequest = {
-  provider: 'relay',
-  sourceAmount: '1000000',
-  sourceAmountUnits: 'baseUnits',
-  sourceChain: 'base',
-  sourceToken: 'USDC',
-} as const
-
-describe('listQuotes', () => {
-  test('returns normalized successful provider quotes', async () => {
-    const attempts: FundingQuotes.ProviderAttempt[] = []
-    let seen: FundingQuotes.QuoteProbeInput | undefined
-    const quotes = await FundingQuotes.listQuotes({
-      ...baseUsdcRequest,
-      adapters: {
-        relay: {
-          async probeQuote(input, signal) {
-            seen = input
-            expect(signal.aborted).toBe(false)
-            return {
-              minimumOutputAmount: '980000',
-              outputAmount: '990000',
-              quality: {
-                estimatedSeconds: 4,
-                liquiditySource: 'providerQuote',
-                sourceDetail: 'providerEndpoint',
-                tier: 'liquid',
-              },
-              sampledAt: '2026-01-01T00:00:00Z',
-              status: 'available',
-            }
-          },
-        },
-      },
-      onAttempt: (attempt) => attempts.push(attempt),
-    })
-
-    expect(seen?.candidate.id).toBe('base-usdc-tempo-usdce-relay')
-    expect(quotes).toHaveLength(1)
-    expect(quotes[0]).toMatchObject({
-      destinationAmount: {
-        baseUnits: '990000',
-        currency: 'USD',
-        decimals: 6,
-        formatted: '0.99',
-      },
-      destinationAmountMin: {
-        baseUnits: '980000',
-        currency: 'USD',
-        decimals: 6,
-        formatted: '0.98',
-      },
-      id: 'base-usdc-tempo-usdce-relay',
-      quality: {
-        liquiditySource: 'providerQuote',
-        tier: 'liquid',
-      },
-      quote: { sampledAt: '2026-01-01T00:00:00Z' },
-      sourceAmount: {
-        baseUnits: '1000000',
-        currency: 'USD',
-        decimals: 6,
-        formatted: '1',
-      },
-    })
-    expect(attempts.map(stableAttempt)).toEqual([{ outcome: 'available', provider: 'relay' }])
-    expect(attempts[0]?.durationMs).toEqual(expect.any(Number))
-  })
-
-  test('returns no static candidates when no adapter is configured', async () => {
-    const attempts: FundingQuotes.ProviderAttempt[] = []
-    await expect(
-      FundingQuotes.listQuotes({
-        ...baseUsdcRequest,
-        onAttempt: (attempt) => attempts.push(attempt),
-      }),
-    ).resolves.toEqual([])
-    expect(attempts).toEqual([])
-  })
-
-  test('omits provider-declared unavailable quotes', async () => {
-    const attempts: FundingQuotes.ProviderAttempt[] = []
-    const quotes = FundingQuotes.listQuotes({
-      ...baseUsdcRequest,
-      adapters: {
-        relay: {
-          async probeQuote() {
-            return { sampledAt: '2026-01-01T00:00:00Z', status: 'unavailable' }
-          },
-        },
-      },
-      onAttempt: (attempt) => attempts.push(attempt),
-    })
-
-    await expect(quotes).resolves.toEqual([])
-    expect(attempts.map(stableAttempt)).toEqual([{ outcome: 'unavailable', provider: 'relay' }])
-  })
-
-  test('rejects provider failures when no quote succeeds', async () => {
-    const attempts: FundingQuotes.ProviderAttempt[] = []
-    const quotes = FundingQuotes.listQuotes({
-      ...baseUsdcRequest,
-      adapters: {
-        relay: {
-          async probeQuote() {
-            throw new Error('upstream unavailable')
-          },
-        },
-      },
-      onAttempt: (attempt) => attempts.push(attempt),
-    })
-
-    const cause = await quotes.catch((error: unknown) => error)
-    expect(cause).toMatchObject({
-      failures: [{ cause: expect.any(Error), provider: 'relay' }],
-      name: 'FundingQuotes.ProviderQuoteError',
-    })
-    expect(attempts.map(stableAttempt)).toEqual([
-      { cause: expect.any(Error), outcome: 'failed', provider: 'relay' },
-    ])
-  })
-
-  test('records thin quotes separately from available quotes', async () => {
-    const attempts: FundingQuotes.ProviderAttempt[] = []
-    const quotes = await FundingQuotes.listQuotes({
-      ...baseUsdcRequest,
-      adapters: {
-        relay: {
-          async probeQuote() {
-            return {
-              outputAmount: '990000',
-              sampledAt: '2026-01-01T00:00:00Z',
-              status: 'thin',
-            }
-          },
-        },
-      },
-      onAttempt: (attempt) => attempts.push(attempt),
-    })
-
-    expect(quotes).toHaveLength(1)
-    expect(attempts.map(stableAttempt)).toEqual([{ outcome: 'thin', provider: 'relay' }])
-  })
-
-  test('rejects successful provider responses without output amounts', async () => {
-    const quotes = FundingQuotes.listQuotes({
-      ...baseUsdcRequest,
-      adapters: {
-        relay: {
-          async probeQuote() {
-            return { sampledAt: '2026-01-01T00:00:00Z', status: 'available' }
-          },
-        },
-      },
-    })
-
-    await expect(quotes).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[FundingQuotes.ProviderQuoteError]`,
-    )
-  })
-
-  test('aborts providers that exceed the quote deadline', async () => {
-    const attempts: FundingQuotes.ProviderAttempt[] = []
-    let aborted = false
-    const quotes = FundingQuotes.listQuotes({
-      ...baseUsdcRequest,
-      adapterTimeoutMs: 1,
-      adapters: {
-        relay: {
-          probeQuote(_input, signal) {
-            signal.addEventListener('abort', () => {
-              aborted = true
-            })
-            return new Promise<FundingQuotes.QuoteProbeResult>(() => {})
-          },
-        },
-      },
-      onAttempt: (attempt) => attempts.push(attempt),
-    })
-
-    await expect(quotes).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[FundingQuotes.ProviderQuoteError]`,
-    )
-    expect(aborted).toBe(true)
-    expect(attempts.map(stableAttempt)).toEqual([
-      {
-        cause: expect.any(FundingQuotes.ProviderAdapterTimeoutError),
-        outcome: 'failed',
-        provider: 'relay',
-      },
-    ])
-  })
-
-  test('passes cache policy through to providers', async () => {
-    let seen: FundingQuotes.QuoteProbeInput | undefined
-    await FundingQuotes.listQuotes({
-      ...baseUsdcRequest,
-      adapters: {
-        relay: {
-          async probeQuote(input) {
-            seen = input
-            return { sampledAt: '2026-01-01T00:00:00Z', status: 'unavailable' }
-          },
-        },
-      },
-      cache: { bypass: true },
-    })
-
-    expect(seen?.cache.bypass).toBe(true)
-  })
-
-  test('returns successful quotes when another provider fails', async () => {
-    const attempts: FundingQuotes.ProviderAttempt[] = []
-    const quotes = await FundingQuotes.listQuotes({
-      ...baseUsdcRequest,
-      adapters: {
-        across: {
-          async probeQuote() {
-            throw new Error('upstream unavailable')
-          },
-        },
-        relay: {
-          async probeQuote() {
-            return {
-              outputAmount: '990000',
-              sampledAt: '2026-01-01T00:00:00Z',
-              status: 'available',
-            }
-          },
-        },
-      },
-      onAttempt: (attempt) => attempts.push(attempt),
-      provider: undefined,
-    })
-
-    expect(quotes).toHaveLength(1)
-    expect(quotes[0]?.provider.id).toBe('relay')
-    expect(attempts.map(stableAttempt)).toEqual([
-      { cause: expect.any(Error), outcome: 'failed', provider: 'across' },
-      { outcome: 'available', provider: 'relay' },
-    ])
-  })
-
-  test('does not let attempt observers change quote outcomes', async () => {
-    const adapters = {
-      relay: {
-        async probeQuote() {
-          return {
-            outputAmount: '990000',
-            sampledAt: '2026-01-01T00:00:00Z',
-            status: 'available' as const,
-          }
-        },
-      },
-    }
-    await expect(
-      FundingQuotes.listQuotes({
-        ...baseUsdcRequest,
-        adapters,
-        onAttempt() {
-          throw new Error('observer failed')
-        },
-      }),
-    ).resolves.toHaveLength(1)
-
-    await expect(
-      FundingQuotes.listQuotes({
-        ...baseUsdcRequest,
-        adapters: {
-          relay: {
-            async probeQuote() {
-              throw new Error('provider failed')
-            },
-          },
-        },
-        onAttempt() {
-          throw new Error('observer failed')
-        },
-      }),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`[FundingQuotes.ProviderQuoteError]`)
-  })
-})
-
-function stableAttempt(attempt: FundingQuotes.ProviderAttempt) {
-  const { durationMs: _durationMs, ...rest } = attempt
-  return rest
-}
-
-describe('listChains', () => {
-  test('returns only chain and token inputs with quote inventory', () => {
-    expect(FundingQuotes.listChains().map((chain) => chain.id)).toEqual([
-      'eip155:1',
-      'eip155:8453',
-      'eip155:56',
-      'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
-      'tron:0x2b6653dc',
-    ])
-  })
-
-  test('uses chain-specific token keys for non-EVM inventory', () => {
-    const chains = FundingQuotes.listChains()
-    expect(chains.find((chain) => chain.kind === 'solana')?.tokens[0]?.tokenKey).toBe(
-      'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-    )
-    expect(chains.find((chain) => chain.kind === 'tron')?.tokens[0]?.tokenKey).toBe(
-      'tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
-    )
-  })
-})
-
-describe('listQuoteCandidates', () => {
-  test('round-trips the advertised Solana chain and token ids', () => {
-    const [candidate] = FundingQuotes.listQuoteCandidates({
-      provider: 'rhino',
-      sourceAmount: '1000000',
-      sourceAmountUnits: 'baseUnits',
-      sourceChain: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
-      sourceToken:
-        'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
-    })
-
-    expect(candidate?.id).toBe('solana-usdc-tempo-usdce-rhino')
-  })
-
-  test('keeps non-EVM token identifiers case-sensitive', () => {
-    expect(
-      FundingQuotes.listQuoteCandidates({
-        provider: 'rhino',
-        sourceAmount: '1000000',
-        sourceAmountUnits: 'baseUnits',
-        sourceChain: 'solana',
-        sourceToken: 'epjfwdd5aufqssqem2qn1xzybapc8g4wegkzwytdt1v',
-      }),
-    ).toEqual([])
-  })
-
-  test('resolves the complete Tron token key', () => {
-    const [candidate] = FundingQuotes.listQuoteCandidates({
-      destinationToken: 'USDT0',
-      provider: 'rhino',
-      sourceAmount: '1000000',
-      sourceAmountUnits: 'baseUnits',
-      sourceChain: 'tron:0x2b6653dc',
-      sourceToken: 'tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
-    })
-
-    expect(candidate?.id).toBe('tron-usdt-tempo-usdt0-rhino')
-  })
-
-  test('selects proven Squid stablecoin corridors', () => {
-    const candidates = [
-      FundingQuotes.listQuoteCandidates({
-        destinationToken: 'USDC.e',
-        provider: 'squid',
-        sourceAmount: '1000000',
-        sourceAmountUnits: 'baseUnits',
-        sourceChain: 'base',
-        sourceToken: 'USDC',
-      })[0],
-      FundingQuotes.listQuoteCandidates({
-        destinationToken: 'USDT0',
-        provider: 'squid',
-        sourceAmount: '1000000',
-        sourceAmountUnits: 'baseUnits',
-        sourceChain: 'ethereum',
-        sourceToken: 'USDT',
-      })[0],
-    ]
-
-    expect(candidates.map((candidate) => candidate?.id)).toEqual([
-      'base-usdc-tempo-usdce-squid',
-      'ethereum-usdt-tempo-usdt0-squid',
-    ])
-  })
-
-  test('selects proven Symbiosis stablecoin corridors', () => {
-    const candidates = [
-      FundingQuotes.listQuoteCandidates({
-        destinationToken: 'USDC.e',
-        provider: 'symbiosis',
-        sourceAmount: '1000000',
-        sourceAmountUnits: 'baseUnits',
-        sourceChain: 'base',
-        sourceToken: 'USDC',
-      })[0],
-      FundingQuotes.listQuoteCandidates({
-        destinationToken: 'USDT0',
-        provider: 'symbiosis',
-        sourceAmount: '1000000',
-        sourceAmountUnits: 'baseUnits',
-        sourceChain: 'ethereum',
-        sourceToken: 'USDT',
-      })[0],
-      FundingQuotes.listQuoteCandidates({
-        destinationToken: 'USDT0',
-        provider: 'symbiosis',
-        sourceAmount: '1000000',
-        sourceAmountUnits: 'baseUnits',
-        sourceChain: 'tron',
-        sourceToken: 'USDT',
-      })[0],
-    ]
-
-    expect(candidates.map((candidate) => candidate?.id)).toEqual([
-      'base-usdc-tempo-usdce-symbiosis',
-      'ethereum-usdt-tempo-usdt0-symbiosis',
-      'tron-usdt-tempo-usdt0-symbiosis',
-    ])
-  })
-})
-
-describe('listProviders', () => {
-  test('reports deployment configuration', () => {
-    expect(FundingQuotes.listProviders()).toMatchInlineSnapshot(`
-      [
-        {
-          "id": "across",
-          "kind": "intentBridge",
-          "name": "Across",
-          "requiresApiKey": true,
-          "status": "unconfigured",
-        },
-        {
-          "id": "relay",
-          "kind": "solverNetwork",
-          "name": "Relay",
-          "requiresApiKey": false,
-          "status": "unconfigured",
-        },
-        {
-          "id": "rhino",
-          "kind": "bridge",
-          "name": "Rhino",
-          "requiresApiKey": false,
-          "status": "unconfigured",
-        },
-        {
-          "id": "squid",
-          "kind": "solverNetwork",
-          "name": "Squid",
-          "requiresApiKey": true,
-          "status": "unconfigured",
-        },
-        {
-          "id": "symbiosis",
-          "kind": "crossChainDex",
-          "name": "Symbiosis",
-          "requiresApiKey": false,
-          "status": "unconfigured",
-        },
-      ]
-    `)
-  })
-})