tapimo 0.6.0 → 0.7.0

package/src/internal/FundingQuotes.ts

@@ -1,3 +1,5 @@
+import * as Value from './Value.js'
+
 /** Tempo mainnet as a CAIP-2 chain reference. */
 const destinationChain = {
   addressFormat: 'evm',
@@ -27,6 +29,7 @@ const sourceChains = [
       {
         address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
         coingeckoId: 'usd-coin',
+        currency: 'USD',
         decimals: 6,
         name: 'USD Coin',
         standard: 'ERC-20',
@@ -35,6 +38,7 @@ const sourceChains = [
       {
         address: '0xdac17f958d2ee523a2206206994597c13d831ec7',
         coingeckoId: 'tether',
+        currency: 'USD',
         decimals: 6,
         name: 'Tether USD',
         standard: 'ERC-20',
@@ -43,6 +47,7 @@ const sourceChains = [
       {
         address: '0x6c3ea9036406852006290770bedfcaba0e23a0e8',
         coingeckoId: 'paypal-usd',
+        currency: 'USD',
         decimals: 6,
         name: 'PayPal USD',
         standard: 'ERC-20',
@@ -51,6 +56,7 @@ const sourceChains = [
       {
         address: '0x1abaea1f7c830bd89acc67ec4af516284b1bc33c',
         coingeckoId: 'euro-coin',
+        currency: 'EUR',
         decimals: 6,
         name: 'Euro Coin',
         standard: 'ERC-20',
@@ -59,6 +65,7 @@ const sourceChains = [
       {
         address: '0x6b175474e89094c44da98b954eedeac495271d0f',
         coingeckoId: 'dai',
+        currency: 'USD',
         decimals: 18,
         name: 'Dai Stablecoin',
         standard: 'ERC-20',
@@ -83,6 +90,7 @@ const sourceChains = [
       {
         address: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
         coingeckoId: 'usd-coin',
+        currency: 'USD',
         decimals: 6,
         name: 'USD Coin',
         standard: 'ERC-20',
@@ -91,6 +99,7 @@ const sourceChains = [
       {
         address: '0xfde4c96c8593536e31f229ea8f37b2ada2699bb2',
         coingeckoId: 'tether',
+        currency: 'USD',
         decimals: 6,
         name: 'Tether USD',
         standard: 'ERC-20',
@@ -99,6 +108,7 @@ const sourceChains = [
       {
         address: '0x60a3e35cc302bfa44cb288bc5a4f316fdb1adb42',
         coingeckoId: 'euro-coin',
+        currency: 'EUR',
         decimals: 6,
         name: 'Euro Coin',
         standard: 'ERC-20',
@@ -122,6 +132,7 @@ const sourceChains = [
       {
         address: '0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d',
         coingeckoId: 'usd-coin',
+        currency: 'USD',
         decimals: 18,
         name: 'Binance-Peg USD Coin',
         standard: 'BEP-20',
@@ -130,6 +141,7 @@ const sourceChains = [
       {
         address: '0x55d398326f99059ff775485246999027b3197955',
         coingeckoId: 'tether',
+        currency: 'USD',
         decimals: 18,
         name: 'Tether USD',
         standard: 'BEP-20',
@@ -151,6 +163,7 @@ const sourceChains = [
       {
         address: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
         coingeckoId: 'usd-coin',
+        currency: 'USD',
         decimals: 6,
         name: 'USD Coin',
         standard: 'SPL',
@@ -173,6 +186,7 @@ const sourceChains = [
       {
         address: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
         coingeckoId: 'tether',
+        currency: 'USD',
         decimals: 6,
         name: 'Tether USD',
         standard: 'TRC-20',
@@ -186,6 +200,7 @@ const sourceChains = [
 const destinationTokens = [
   {
     address: '0x20c0000000000000000000000000000000000000',
+    currency: 'USD',
     decimals: 6,
     name: 'pathUSD',
     slug: 'pathusd',
@@ -194,6 +209,7 @@ const destinationTokens = [
   },
   {
     address: '0x20c000000000000000000000b9537d11c60e8b50',
+    currency: 'USD',
     decimals: 6,
     name: 'Bridged USDC (Stargate)',
     slug: 'usdce',
@@ -202,6 +218,7 @@ const destinationTokens = [
   },
   {
     address: '0x20c0000000000000000000001621e21f71cf12fb',
+    currency: 'EUR',
     decimals: 6,
     name: 'Bridged EURC',
     slug: 'eurce',
@@ -210,6 +227,7 @@ const destinationTokens = [
   },
   {
     address: '0x20c00000000000000000000014f22ca97301eb73',
+    currency: 'USD',
     decimals: 6,
     name: 'USDT0',
     slug: 'usdt0',
@@ -218,6 +236,7 @@ const destinationTokens = [
   },
   {
     address: '0x20c0000000000000000000003554d28269e0f3c2',
+    currency: 'USD',
     decimals: 6,
     name: 'frxUSD',
     slug: 'frxusd',
@@ -346,8 +365,6 @@ export type QuoteProbeResult = {
   minimumOutputAmount?: string | undefined
   /** Expected destination amount in base units. */
   outputAmount?: string | undefined
-  /** Expected destination amount rendered with destination token decimals. */
-  outputAmountFormatted?: string | undefined
   /** Timestamp for the live quote probe. */
   sampledAt: string
   /** Provider-specific quote status for the requested amount. */
@@ -659,6 +676,7 @@ function formatChain(chain: SourceChainInput) {
 function formatDestinationToken(token: DestinationTokenInput) {
   return {
     address: token.address,
+    currency: token.currency,
     decimals: token.decimals,
     metadata: {},
     name: token.name,
@@ -706,6 +724,7 @@ function formatQuoteCandidate(options: {
 function formatSourceToken(chain: SourceChainInput, token: TokenInput) {
   return {
     address: token.address,
+    currency: token.currency,
     decimals: token.decimals,
     metadata: { coingeckoId: token.coingeckoId },
     name: token.name,
@@ -741,7 +760,24 @@ type SuccessfulQuoteProbe = QuoteProbeResult & {
 
 function formatFundingQuote(candidate: QuoteCandidate, quote: SuccessfulQuoteProbe) {
   return {
-    ...candidate,
+    destinationAmount: Value.tokenAmount({
+      baseUnits: quote.outputAmount,
+      currency: candidate.destinationToken.currency,
+      decimals: candidate.destinationToken.decimals,
+    }),
+    ...(quote.minimumOutputAmount !== undefined
+      ? {
+          destinationAmountMin: Value.tokenAmount({
+            baseUnits: quote.minimumOutputAmount,
+            currency: candidate.destinationToken.currency,
+            decimals: candidate.destinationToken.decimals,
+          }),
+        }
+      : {}),
+    destinationChain: candidate.destinationChain,
+    destinationToken: candidate.destinationToken,
+    id: candidate.id,
+    provider: candidate.provider,
     quality: {
       ...(quote.quality?.estimatedSeconds !== undefined
         ? { estimatedSeconds: quote.quality.estimatedSeconds }
@@ -754,16 +790,15 @@ function formatFundingQuote(candidate: QuoteCandidate, quote: SuccessfulQuotePro
     },
     quote: {
       ...(quote.expiresAt !== undefined ? { expiresAt: quote.expiresAt } : {}),
-      inputAmount: candidate.sourceAmount.amount,
-      ...(quote.minimumOutputAmount !== undefined
-        ? { minimumOutputAmount: quote.minimumOutputAmount }
-        : {}),
-      outputAmount: quote.outputAmount,
-      outputAmountFormatted:
-        quote.outputAmountFormatted ??
-        decimalFromBaseUnits(quote.outputAmount, candidate.destinationToken.decimals),
       sampledAt: quote.sampledAt,
     },
+    sourceAmount: Value.tokenAmount({
+      baseUnits: candidate.sourceAmount.amount,
+      currency: candidate.sourceToken.currency,
+      decimals: candidate.sourceToken.decimals,
+    }),
+    sourceChain: candidate.sourceChain,
+    sourceToken: candidate.sourceToken,
   } as const
 }
 

package/src/internal/Log.test.ts

@@ -138,6 +138,97 @@ describe('middleware', () => {
     `)
   })
 
+  test('records a JSON-RPC error returned with HTTP 200', async () => {
+    const entries: Log.Entry[] = []
+    const api = app({ emit: (entry) => void entries.push(entry) })
+    api.post('/rpc/sponsor', (c) => {
+      const body = {
+        error: {
+          code: -32602,
+          data: { code: 'billing_required', retryable: false },
+          message: 'Sponsorship requires an active billing source.',
+        },
+        id: 1,
+        jsonrpc: '2.0',
+      }
+      c.set('rpcResponse', Log.rpcErrors(body))
+      return c.json(body)
+    })
+
+    const response = await api.request('/rpc/sponsor', { method: 'POST' })
+
+    expect(response.status).toBe(200)
+    expect(stable(entries[0]!)).toMatchInlineSnapshot(`
+      {
+        "level": "warn",
+        "method": "POST",
+        "path": "/rpc/sponsor",
+        "route": "/rpc/sponsor",
+        "rpc": {
+          "code": -32602,
+          "dataCode": "billing_required",
+          "errors": 1,
+        },
+        "status": 200,
+      }
+    `)
+  })
+
+  test('logs JSON-RPC server errors at error level', async () => {
+    const entries: Log.Entry[] = []
+    const api = app({ emit: (entry) => void entries.push(entry) })
+    api.post('/rpc/sponsor', (c) => {
+      const body = {
+        error: {
+          code: -32603,
+          data: { code: 'internal_error' },
+          message: 'Internal error',
+        },
+        id: 1,
+        jsonrpc: '2.0',
+      }
+      c.set('rpcResponse', Log.rpcErrors(body))
+      return c.json(body)
+    })
+
+    await api.request('/rpc/sponsor', { method: 'POST' })
+
+    expect(entries[0]?.level).toBe('error')
+  })
+
+  test('counts batch JSON-RPC errors without retaining mixed codes', async () => {
+    const entries: Log.Entry[] = []
+    const api = app({ emit: (entry) => void entries.push(entry) })
+    api.post('/rpc/relay', (c) => {
+      const body = [
+        { id: 1, jsonrpc: '2.0', result: '0x1' },
+        { error: { code: -32602, message: 'Invalid params.' }, id: 2, jsonrpc: '2.0' },
+        {
+          error: { code: -32603, data: { code: 'Internal Error' }, message: 'Internal error.' },
+          id: 3,
+          jsonrpc: '2.0',
+        },
+      ]
+      c.set('rpcResponse', Log.rpcErrors(body))
+      return c.json(body)
+    })
+
+    await api.request('/rpc/relay', { method: 'POST' })
+
+    expect(stable(entries[0]!)).toMatchInlineSnapshot(`
+      {
+        "level": "warn",
+        "method": "POST",
+        "path": "/rpc/relay",
+        "route": "/rpc/relay",
+        "rpc": {
+          "errors": 2,
+        },
+        "status": 200,
+      }
+    `)
+  })
+
   test('includes redacted provider failure details', async () => {
     const entries: Log.Entry[] = []
     const api = app({ emit: (entry) => void entries.push(entry) })

package/src/internal/Log.ts

@@ -17,6 +17,8 @@ export type Variables = {
   providerFailure?: Entry['provider'] | undefined
   /** Redacted provider failures when multiple upstream adapters fail. */
   providerFailures?: Entry['providerFailures'] | undefined
+  /** Bounded JSON-RPC failure metadata recorded by a composed RPC handler. */
+  rpcResponse?: Entry['rpc'] | undefined
 }
 
 /** Hono environment shape used by the request logger. */
@@ -71,7 +73,7 @@ export type Entry = {
   errorCode?: string | undefined
   /** Bounded funding provider attempts made while serving the request. */
   fundingProviderAttempts?: readonly FundingProviderAttempt[] | undefined
-  /** Log level derived from the response status: 5xx `error`, 4xx `warn`, else `info`. */
+  /** Log level: 5xx `error`; 4xx or JSON-RPC failure `warn`; otherwise `info`. */
   level: Level
   /** Request method. */
   method: string
@@ -121,7 +123,16 @@ export type Entry = {
   requestId: string
   /** Matched handler path (bounded cardinality), e.g. `/v1/tokens/:address`; `/*` when a middleware (e.g. an edge-cache hit) short-circuited routing. */
   route: string
-  /** Response status code. */
+  /** JSON-RPC failures returned in an otherwise successful HTTP response. */
+  rpc?: {
+    /** Numeric JSON-RPC error code when every failed response shares one code. */
+    code?: number | undefined
+    /** Stable application error code from `error.data.code`, when shared by every failed response. */
+    dataCode?: string | undefined
+    /** Number of failed responses in the single or batch JSON-RPC response. */
+    errors: number
+  }
+  /** HTTP response status code. JSON-RPC failures retain their protocol-native `200`. */
   status: number
   /** Upstream operation durations in milliseconds, from the request's Server-Timing metrics (e.g. RPC and TIDX calls). */
   timings?: Record<string, number> | undefined
@@ -138,8 +149,9 @@ export type Emit = (entry: Entry) => Promise<void> | void
  *
  * The entry derives everything from state other layers already produce —
  * `requestId`, the auth principal, `RateLimit-*` headers, Server-Timing
- * metrics, the `errorCode` recorded by `Response.error`, and the edge-cache
- * hit marker — so handlers never log per-request lines themselves.
+ * metrics, the `errorCode` recorded by `Response.error`, JSON-RPC response
+ * errors, and the edge-cache hit marker, so handlers never log per-request
+ * lines themselves.
  */
 export function middleware<environment extends Environment = Environment>(
   options: middleware.Options = {},
@@ -164,6 +176,7 @@ export function middleware<environment extends Environment = Environment>(
       | undefined
     const provider = c.get('providerFailure' as never) as Entry['provider']
     const providerFailures = c.get('providerFailures' as never) as Entry['providerFailures']
+    const rpc = c.get('rpcResponse' as never) as Entry['rpc']
 
     // The `request` total metric duplicates `duration` (measured here, one
     // layer further out), so only operation timings are kept.
@@ -193,7 +206,12 @@ export function middleware<environment extends Environment = Environment>(
       duration: round(duration),
       ...(errorCode === undefined ? {} : { errorCode }),
       ...(fundingProviderAttempts === undefined ? {} : { fundingProviderAttempts }),
-      level: status >= 500 ? 'error' : status >= 400 ? 'warn' : 'info',
+      level:
+        status >= 500 || rpcServerError(rpc?.code)
+          ? 'error'
+          : status >= 400 || rpc
+            ? 'warn'
+            : 'info',
       method: c.req.method,
       path: url.pathname,
       ...(principal?.payment === undefined ? {} : { payment: principal.payment.reason }),
@@ -220,6 +238,7 @@ export function middleware<environment extends Environment = Environment>(
       ...(rateLimit === undefined ? {} : { rateLimit }),
       requestId: c.get('requestId' as never) as string,
       route: c.req.routePath,
+      ...(rpc === undefined ? {} : { rpc }),
       status,
       ...(timings === undefined ? {} : { timings }),
     })
@@ -238,6 +257,51 @@ export function middleware<environment extends Environment = Environment>(
   }
 }
 
+const rpcDataCode = /^[a-z][a-z0-9_]{0,63}$/
+
+/** Extracts bounded error metadata from an already-parsed JSON-RPC response. */
+export function rpcErrors(body: unknown): Entry['rpc'] {
+  const values = Array.isArray(body) ? body : [body]
+  const errors = values.flatMap((value) => {
+    if (!value || typeof value !== 'object') return []
+    const record = value as Record<string, unknown>
+    if (record['jsonrpc'] !== '2.0' || !record['error'] || typeof record['error'] !== 'object')
+      return []
+    const error = record['error'] as Record<string, unknown>
+    if (
+      !Number.isInteger(error['code']) ||
+      Number(error['code']) < -2_147_483_648 ||
+      Number(error['code']) > 2_147_483_647
+    )
+      return []
+    const data = error['data']
+    const dataCode_value =
+      data && typeof data === 'object' ? (data as Record<string, unknown>)['code'] : undefined
+    const dataCode = typeof dataCode_value === 'string' ? dataCode_value : undefined
+    return [
+      {
+        code: error['code'] as number,
+        ...(dataCode && rpcDataCode.test(dataCode) ? { dataCode } : {}),
+      },
+    ]
+  })
+  if (errors.length === 0) return undefined
+
+  const codes = new Set(errors.map((error) => error.code))
+  const dataCodes = new Set(errors.map((error) => error.dataCode).filter(Boolean))
+  return {
+    ...(codes.size === 1 ? { code: errors[0]!.code } : {}),
+    ...(dataCodes.size === 1 && errors.every((error) => error.dataCode !== undefined)
+      ? { dataCode: errors[0]!.dataCode }
+      : {}),
+    errors: Math.min(errors.length, 65_535),
+  }
+}
+
+function rpcServerError(code: number | undefined) {
+  return code === -32603 || (code !== undefined && code >= -32099 && code <= -32000)
+}
+
 export declare namespace middleware {
   /** Options for the request logger middleware. */
   type Options = {

package/src/internal/MetricSink.test.ts

@@ -10,6 +10,61 @@ type MetricEvent = {
 }
 
 describe('requests', () => {
+  test('records JSON-RPC errors with bounded code tags', () => {
+    const events: MetricEvent[] = []
+    const metrics = Metrics.from({
+      count(name, value, tags) {
+        events.push({ name, tags, type: 'count', value })
+      },
+      flush() {},
+      gauge() {},
+      histogram() {},
+    })
+    const record = MetricSink.requests(metrics)
+
+    record({
+      duration: 10,
+      level: 'warn',
+      method: 'POST',
+      path: '/rpc/relay',
+      requestId: 'request_private',
+      route: '/rpc/relay',
+      rpc: { code: -32602, dataCode: 'billing_required', errors: 2 },
+      status: 200,
+    })
+
+    expect(events).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "http_response_count",
+          "tags": {
+            "cache": "miss",
+            "method": "POST",
+            "principal_environment": "none",
+            "principal_type": "unknown",
+            "route": "/rpc/relay",
+            "status": 200,
+          },
+          "type": "count",
+          "value": 1,
+        },
+        {
+          "name": "rpc_response_error_count",
+          "tags": {
+            "cache": "miss",
+            "method": "POST",
+            "principal_environment": "none",
+            "principal_type": "unknown",
+            "route": "/rpc/relay",
+            "rpc_error_code": "-32602",
+          },
+          "type": "count",
+          "value": 2,
+        },
+      ]
+    `)
+  })
+
   test('records bounded funding provider attempts without caller data', () => {
     const events: MetricEvent[] = []
     let flushes = 0

package/src/internal/MetricSink.ts

@@ -85,6 +85,12 @@ export function requests(backend: Metrics): RequestSink {
     })
     backend.histogram('http_response_duration_ms', entry.duration, tags)
 
+    if (entry.rpc)
+      backend.count('rpc_response_error_count', entry.rpc.errors, {
+        ...tags,
+        rpc_error_code: rpcErrorCode(entry.rpc.code),
+      })
+
     if (entry.status === 429 || entry.errorCode === 'rate_limit_exceeded')
       backend.count('http_rate_limit_count', 1, {
         ...tags,
@@ -109,6 +115,14 @@ export function requests(backend: Metrics): RequestSink {
   }
 }
 
+/** Maps arbitrary upstream JSON-RPC codes into bounded metric tags. */
+function rpcErrorCode(code: number | undefined) {
+  if (code === undefined) return 'mixed'
+  if ([-32700, -32600, -32601, -32602, -32603].includes(code)) return String(code)
+  if (code >= -32099 && code <= -32000) return 'server'
+  return 'other'
+}
+
 function routeTags(entry: Log.Entry): RouteTags {
   return {
     cache: entry.cache ?? 'miss',

package/src/internal/Response.test.ts

@@ -0,0 +1,28 @@
+import { Hono } from 'hono'
+
+import * as Response from './Response.js'
+
+describe('upstream', () => {
+  test('returns a stable message and preserves the cause on context', async () => {
+    const app = new Hono()
+    const cause = new Error('provider URL contains secret credentials')
+    let captured: Error | undefined
+
+    app.use(async (c, next) => {
+      await next()
+      captured = c.error
+    })
+    app.get('/', (c) => Response.upstream(c, cause))
+
+    const response = await app.request('/')
+    expect(await response.json()).toMatchInlineSnapshot(`
+      {
+        "error": {
+          "code": "upstream_error",
+          "message": "Upstream service could not complete the request",
+        },
+      }
+    `)
+    expect(captured).toBe(cause)
+  })
+})

package/src/internal/Response.ts

@@ -39,12 +39,20 @@ export function unsupportedChainId(c: Context, chainId: number, supported: Itera
 }
 
 /**
- * Maps an unexpected upstream failure to a 502 JSON error envelope. Rethrows
- * non-`Error` causes so the global handler can convert them.
+ * Maps an unexpected upstream failure to a stable 502 JSON error envelope.
+ * Preserves `Error` causes for reporting and rethrows non-`Error` causes.
  */
 export function upstream(c: Context, cause: unknown) {
-  if (cause instanceof Error)
-    return error(c, { code: 'upstream_error', message: cause.message, status: 502 })
+  if (cause instanceof Error) {
+    // Preserve the original error for error-reporting middleware without
+    // exposing provider URLs, payloads, or credentials in the response.
+    c.error = cause
+    return error(c, {
+      code: 'upstream_error',
+      message: 'Upstream service could not complete the request',
+      status: 502,
+    })
+  }
   throw cause
 }