tapimo 0.4.3 → 0.4.4

package/src/App.test.ts

@@ -1,10 +1,12 @@
 import * as http from 'node:http'
+import { Challenge } from 'mppx'
 import { ApiKeys, App, Metrics, RateLimit, Store } from 'tapimo'
 import * as Docs from 'tapimo/docs'
 import * as Tokens from './apps/data/routes/tokens.js'
 import type * as Log from './internal/Log.js'
 import * as TestApp from '../test/App.js'
 import * as Runtime from '../test/runtime.js'
+import * as Tempo from '../test/Tempo.js'
 
 describe('create', () => {
   test('composes default dependencies', async () => {
@@ -208,6 +210,53 @@ describe('create', () => {
     `)
   })
 
+  test('applies the configured global MPP rate limit', async () => {
+    const store = Store.memory()
+    const limit = { perMinute: 2 }
+    const app = TestApp.create({
+      mpp: { rateLimit: limit },
+      rateLimit: { store },
+    })
+    await exhaustQuota(RateLimit.memory({ store }), 'mpp:public:203.0.113.10', limit)
+
+    const response = await app.request(`/v1/tokens/${TestApp.token}`, {
+      headers: {
+        authorization: 'Payment malformed',
+        'x-forwarded-for': '203.0.113.10',
+      },
+    })
+
+    expect(response.status).toBe(429)
+    expect(response.headers.get('RateLimit-Limit')).toBe('2')
+    expect(response.headers.get('RateLimit-Scope')).toBe('mpp')
+  })
+
+  test('endpoint MPP rate limit overrides the global limit', async () => {
+    const store = Store.memory()
+    const routeLimit = { perMinute: 1 }
+    const app = TestApp.create({
+      auth: {
+        overrides: {
+          'GET /v1/tokens/:token': { mpp: { rateLimit: routeLimit } },
+        },
+      },
+      mpp: { rateLimit: { perMinute: 2 } },
+      rateLimit: { store },
+    })
+    await exhaustQuota(RateLimit.memory({ store }), 'mpp:public:203.0.113.10', routeLimit)
+
+    const response = await app.request(`/v1/tokens/${TestApp.token}`, {
+      headers: {
+        authorization: 'Payment malformed',
+        'x-forwarded-for': '203.0.113.10',
+      },
+    })
+
+    expect(response.status).toBe(429)
+    expect(response.headers.get('RateLimit-Limit')).toBe('1')
+    expect(response.headers.get('RateLimit-Scope')).toBe('mpp')
+  })
+
   test('serves Vocs API reference', async () => {
     const app = TestApp.create({ docs: Docs.docs() })
     const response = await app.request('/')
@@ -602,11 +651,13 @@ describe('create', () => {
       auth,
       cache: { store },
       mpp: {
-        charge: {
-          currency: 'USD',
-          decimals: 2,
-        },
         secretKey: 'secret_test_key_0123456789abcdef',
+        session: {
+          chainId: Tempo.chain.id,
+          decimals: 6,
+          getClient: () => Tempo.client,
+          recipient: Tempo.accounts[2].address,
+        },
       },
       rateLimit: {
         now,
@@ -627,6 +678,11 @@ describe('create', () => {
     })
     const overQuota = await app.request('/v1/tokens/not-an-address')
     expect(overQuota.status).toMatchInlineSnapshot(`402`)
+    expect(Challenge.fromHeaders(overQuota.headers).request['currency']).toBe(Tempo.currency)
+
+    const head = await app.request('/v1/tokens/not-an-address', { method: 'HEAD' })
+    expect(head.status).toMatchInlineSnapshot(`402`)
+    expect(Challenge.fromHeaders(head.headers).intent).toBe('session')
   })
 
   test('supports bearer API-key fallback', async () => {

package/src/Client.test-d.ts

@@ -1221,53 +1221,6 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('POST /v1/funding/routes/quote', async () => {
-    const client = Client.create()
-    const res = await client.v1.funding.routes.quote.$post({
-      json: {
-        depositor: '0x1111111111111111111111111111111111111111',
-        provider: 'across',
-        sourceAmount: '1000000',
-        sourceChain: 'base',
-        sourceToken: 'USDC',
-      },
-    })
-
-    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 501 | 502 | PaidAccessStatus>()
-
-    switch (res.status) {
-      case 200: {
-        const json = await res.json()
-        expectTypeOf(json).toEqualTypeOf<
-          z.output<typeof Funding.schema.quoteFundingRoute.Response>
-        >()
-        return
-      }
-      case 400: {
-        const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'body_invalid'>>()
-        return
-      }
-      case 404: {
-        const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'quote_unavailable' | 'route_not_found'>()
-        return
-      }
-      case 501: {
-        const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'provider_unconfigured'>()
-        return
-      }
-      case 502: {
-        const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<
-          'provider_error' | 'provider_rate_limited' | 'provider_timeout'
-        >()
-        return
-      }
-    }
-  })
-
   test('GET /v1/funding/chains', async () => {
     const client = Client.create()
     const res = await client.v1.funding.chains.$get()

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

@@ -4,249 +4,6 @@ import * as FundingRouteProviders from './FundingRouteProviders.js'
 const now = () => new Date('2026-01-01T00:00:00.000Z')
 
 describe('FundingRouteProviders', () => {
-  test('maps Across suggested-fees responses into quote probes', async () => {
-    const requests: RecordedRequest[] = []
-    const fetch = recordingFetch(requests, async () =>
-      jsonResponse({
-        estimatedFillTimeSec: 2,
-        limits: {
-          maxDeposit: '2000000',
-          maxDepositInstant: '1500000',
-          minDeposit: '500000',
-        },
-        outputAmount: '990000',
-        relayFeePct: '1200000000000000',
-        timestamp: '1767225600',
-      }),
-    )
-    const adapter = FundingRouteProviders.across({
-      apiKey: 'across-api-key',
-      baseUrl: 'https://across.test/api/',
-      fetch,
-      integratorId: 'tempo',
-      now,
-    })
-
-    const result = await adapter.probeQuote(
-      await probeInput('across'),
-      new AbortController().signal,
-    )
-
-    expect(requests).toHaveLength(1)
-    expect(requests[0]?.url.pathname).toBe('/api/suggested-fees')
-    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('tempo')
-    expect(requests[0]?.url.searchParams.get('allowUnmatchedDecimals')).toBe('true')
-    expect(new Headers(requests[0]?.init?.headers).get('authorization')).toBe(
-      'Bearer across-api-key',
-    )
-    expect(result).toMatchObject({
-      expiresAt: '2026-01-01T00:10:00.000Z',
-      limits: {
-        instantSourceAmount: '1500000',
-        maxSourceAmount: '2000000',
-        minSourceAmount: '500000',
-      },
-      outputAmount: '990000',
-      outputAmountFormatted: '0.99',
-      quality: {
-        availableVolumeUsd: '2',
-        estimatedSeconds: 2,
-        feeBps: 12,
-        instantVolumeUsd: '1.5',
-        liquiditySource: 'providerLimit',
-        sourceDetail: 'across:suggested-fees',
-        tier: 'liquid',
-      },
-      sampledAt: '2026-01-01T00:00:00.000Z',
-      status: 'available',
-    })
-  })
-
-  test('maps recognized Across quote errors to unavailable probes', async () => {
-    const fetch = recordingFetch([], async () =>
-      jsonResponse({ code: 'AMOUNT_TOO_HIGH', message: 'Amount exceeds max deposit' }, 400),
-    )
-    const adapter = FundingRouteProviders.across({
-      apiKey: 'across-api-key',
-      fetch,
-      integratorId: 'tempo',
-      now,
-    })
-
-    const result = await adapter.probeQuote(
-      await probeInput('across'),
-      new AbortController().signal,
-    )
-
-    expect(result).toMatchObject({
-      quality: {
-        liquiditySource: 'providerLimit',
-        score: 0,
-        sourceDetail: 'across:suggested-fees:AMOUNT_TOO_HIGH',
-        tier: 'unavailable',
-      },
-      sampledAt: '2026-01-01T00:00:00.000Z',
-      status: 'unavailable',
-    })
-  })
-
-  test('builds an authenticated exact-input Across quote request', async () => {
-    const route = await staticRoute('across')
-    const request = FundingRouteProviders.createAcrossQuoteRequest({
-      apiKey: 'across-api-key',
-      baseUrl: 'https://across.test/api/',
-      depositor: '0x1111111111111111111111111111111111111111',
-      integratorId: '0xdead',
-      recipient: '0x2222222222222222222222222222222222222222',
-      route,
-    })
-
-    expect(request.url.pathname).toBe('/api/swap/approval')
-    expect(request.url.searchParams.get('originChainId')).toBe('8453')
-    expect(request.url.searchParams.get('destinationChainId')).toBe('4217')
-    expect(request.url.searchParams.get('amount')).toBe('1000000')
-    expect(request.url.searchParams.get('integratorId')).toBe('0xdead')
-    expect(request.url.searchParams.get('tradeType')).toBe('exactInput')
-    expect(request.url.searchParams.get('skipOriginTxEstimation')).toBe('true')
-    expect(request.url.searchParams.get('strictTradeType')).toBe('true')
-    expect(request.url.searchParams.get('depositor')).toBe(
-      '0x1111111111111111111111111111111111111111',
-    )
-    expect(request.url.searchParams.get('recipient')).toBe(
-      '0x2222222222222222222222222222222222222222',
-    )
-    expect(new Headers(request.headers).get('authorization')).toBe('Bearer across-api-key')
-  })
-
-  test('calls the runtime fetch method with its global receiver', async () => {
-    const route = await staticRoute('across')
-    vi.useFakeTimers()
-    vi.setSystemTime(now())
-    const fetch = vi.fn(function (this: unknown) {
-      expect(this).toBe(globalThis)
-      return Promise.resolve(jsonResponse(acrossQuoteResponse(route)))
-    })
-    vi.stubGlobal('fetch', fetch)
-
-    try {
-      const quote = FundingRouteProviders.acrossQuote({
-        apiKey: 'across-api-key',
-        integratorId: '0xdead',
-      })
-      const result = await quote(
-        { depositor: '0x1111111111111111111111111111111111111111', route },
-        new AbortController().signal,
-      )
-
-      expect(result.outputAmount).toBe('990000')
-      expect(fetch).toHaveBeenCalledOnce()
-    } finally {
-      vi.unstubAllGlobals()
-      vi.useRealTimers()
-    }
-  })
-
-  test('normalizes an Across quote payload', async () => {
-    const route = await staticRoute('across')
-    const result = FundingRouteProviders.parseAcrossQuote({
-      body: acrossQuoteResponse(route),
-      now: now(),
-      route,
-    })
-
-    expect(result).toMatchObject({
-      estimatedSeconds: 2,
-      expiresAt: '2026-01-01T00:01:00.000Z',
-      fees: {
-        total: {
-          amount: '1200',
-          amountUsd: '0.0012',
-          bps: 12,
-          token: { chainId: 'eip155:8453', symbol: 'USDC' },
-        },
-        totalMax: {
-          amount: '1800',
-          amountUsd: '0.0018',
-          bps: 18,
-          token: { chainId: 'eip155:8453', symbol: 'USDC' },
-        },
-      },
-      minimumOutputAmount: '988000',
-      outputAmount: '990000',
-      sampledAt: '2026-01-01T00:00:00.000Z',
-    })
-  })
-
-  test('maps Across HTTP errors into stable provider errors', () => {
-    expect(
-      FundingRouteProviders.mapAcrossQuoteError({ body: { code: 'RATE_LIMITED' }, status: 429 }),
-    ).toBeInstanceOf(FundingRoutes.ProviderRateLimitError)
-    expect(
-      FundingRouteProviders.mapAcrossQuoteError({ body: { code: 'NO_ROUTE' }, status: 400 }),
-    ).toBeInstanceOf(FundingRoutes.ProviderQuoteUnavailableError)
-    const error = FundingRouteProviders.mapAcrossQuoteError({
-      body: { code: 'NOT_FOUND' },
-      status: 404,
-    })
-    expect(error).toMatchObject({ name: 'FundingRouteProviders.ProviderResponseError' })
-    expect(FundingRouteProviders.acrossQuoteFailure({ cause: error })).toEqual({
-      code: 'NOT_FOUND',
-      failure: 'http',
-      id: 'across',
-      operation: 'swap/approval',
-      status: 404,
-    })
-  })
-
-  test('rejects invalid Across configuration during adapter construction', () => {
-    expect(() =>
-      FundingRouteProviders.acrossQuote({ apiKey: 'across-api-key', integratorId: 'tempo' }),
-    ).toThrowErrorMatchingInlineSnapshot(`[FundingRouteProviders.ProviderConfigurationError]`)
-  })
-
-  test('rejects malformed Across quote payloads', async () => {
-    const route = await staticRoute('across')
-    const failure = (() => {
-      try {
-        FundingRouteProviders.parseAcrossQuote({
-          body: { expectedOutputAmount: '990000' },
-          now: now(),
-          route,
-        })
-        throw new Error('Expected malformed payload to fail')
-      } catch (cause) {
-        return cause
-      }
-    })()
-    expect(failure).toMatchObject({ name: 'FundingRouteProviders.ProviderPayloadError' })
-    expect(FundingRouteProviders.acrossQuoteFailure({ cause: failure })).toEqual({
-      failure: 'payload',
-      id: 'across',
-      operation: 'swap/approval',
-    })
-  })
-
-  test('rejects inconsistent Across fee summaries', async () => {
-    const route = await staticRoute('across')
-    const body = acrossQuoteResponse(route)
-    body.fees.totalMax.amount = '1000'
-    expect(() => FundingRouteProviders.parseAcrossQuote({ body, now: now(), route })).toThrow(
-      expect.objectContaining({ name: 'FundingRouteProviders.ProviderPayloadError' }),
-    )
-  })
-
-  test('rejects mismatched Across fee tokens', async () => {
-    const route = await staticRoute('across')
-    const body = acrossQuoteResponse(route)
-    body.fees.total.token.address = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48'
-    expect(() => FundingRouteProviders.parseAcrossQuote({ body, now: now(), route })).toThrow(
-      expect.objectContaining({ name: 'FundingRouteProviders.ProviderPayloadError' }),
-    )
-  })
-
   test('maps Relay liquidity and quote responses into quote probes', async () => {
     const requests: RecordedRequest[] = []
     const route = await staticRoute('relay')
@@ -319,6 +76,43 @@ describe('FundingRouteProviders', () => {
     })
   })
 
+  test('calls the runtime fetch method with its global receiver', async () => {
+    const route = await staticRoute('relay')
+    const fetch = vi.fn(function (this: unknown, input: Parameters<typeof globalThis.fetch>[0]) {
+      expect(this).toBe(globalThis)
+      const url = toUrl(input)
+      return Promise.resolve(
+        jsonResponse(
+          url.pathname === '/quote/v2'
+            ? {
+                details: {
+                  currencyOut: { amount: '990000', minimumAmount: '980000' },
+                  timeEstimate: 15,
+                },
+              }
+            : { liquidity: [] },
+        ),
+      )
+    })
+    vi.stubGlobal('fetch', fetch)
+
+    try {
+      const adapter = FundingRouteProviders.relay({
+        now,
+        userAddress: '0x1111111111111111111111111111111111111111',
+      })
+      const result = await adapter.probeQuote(
+        probeInputFromRoute(route),
+        new AbortController().signal,
+      )
+
+      expect(result.outputAmount).toBe('990000')
+      expect(fetch).toHaveBeenCalledTimes(2)
+    } finally {
+      vi.unstubAllGlobals()
+    }
+  })
+
   test('keeps Relay quotes when the liquidity probe fails', async () => {
     const route = await staticRoute('relay')
     const fetch = recordingFetch([], async (request) => {
@@ -378,10 +172,6 @@ async function staticRoute(
   return route as FundingRoutes.QuoteProbeInput['route']
 }
 
-async function probeInput(provider: FundingRoutes.ProviderId) {
-  return probeInputFromRoute(await staticRoute(provider))
-}
-
 function probeInputFromRoute(
   route: FundingRoutes.QuoteProbeInput['route'],
 ): FundingRoutes.QuoteProbeInput {
@@ -406,56 +196,6 @@ function probeInputFromRoute(
   }
 }
 
-function acrossQuoteResponse(route: FundingRoutes.QuoteProbeInput['route']) {
-  return {
-    amountType: 'exactInput',
-    approvalTxns: [{ data: '0x1234', to: '0x2222222222222222222222222222222222222222' }],
-    checks: { balance: { actual: '1000000', expected: '1000000' } },
-    expectedFillTime: 2,
-    expectedOutputAmount: '990000',
-    fees: {
-      total: {
-        amount: '1200',
-        amountUsd: '0.0012',
-        pct: '1200000000000000',
-        token: {
-          address: route.sourceToken.address,
-          chainId: 8453,
-          decimals: 6,
-          symbol: 'USDC',
-        },
-      },
-      totalMax: {
-        amount: '1800',
-        amountUsd: '0.0018',
-        pct: '1800000000000000',
-        token: {
-          address: route.sourceToken.address,
-          chainId: 8453,
-          decimals: 6,
-          symbol: 'USDC',
-        },
-      },
-    },
-    inputAmount: '1000000',
-    inputToken: {
-      address: route.sourceToken.address,
-      chainId: 8453,
-      decimals: 6,
-      symbol: 'USDC',
-    },
-    minOutputAmount: '988000',
-    outputToken: {
-      address: route.destinationToken.address,
-      chainId: 4217,
-      decimals: 6,
-      symbol: 'USDC.e',
-    },
-    quoteExpiryTimestamp: 1767225660,
-    swapTx: { data: '0xabcd', to: '0x3333333333333333333333333333333333333333' },
-  }
-}
-
 function recordingFetch(
   requests: RecordedRequest[],
   respond: (request: RecordedRequest) => Response | Promise<Response>,