tapimo 0.6.0 → 0.7.1

package/src/internal/Auth.ts

@@ -16,8 +16,6 @@ import * as ApiKey from '../ApiKey.js'
 import * as ApiKeys from '../ApiKeys.js'
 import * as Db from '../db/Db.js'
 import type * as Store from './Store.js'
-import * as EarlyAccess from '../db/tables/earlyAccess.js'
-import * as Invitations from '../db/tables/invitations.js'
 import * as Memberships from '../db/tables/memberships.js'
 import * as Metadata from '../apps/metadata.js'
 import * as OpenApi from './OpenApi.js'
@@ -32,6 +30,7 @@ import * as Viem from './Viem.js'
 
 const policySymbol = Symbol('tempo-api.auth.policy')
 const mppManagementSymbol = Symbol('tempo-api.auth.mpp-management')
+const defaultApiKeyRateLimit = { perMinute: 10_000 } satisfies RateLimit.Limit
 const defaultMppRateLimit = { perMinute: 100 } satisfies RateLimit.Limit
 
 /** Auth context consumed by Tempo API handlers. */
@@ -159,8 +158,6 @@ export type PolicyOverride = {
     | undefined
   /** Session lane: `true` allows signed-in wallet sessions, `false` disables. */
   session?: boolean | undefined
-  /** Temporary early-access gate: `true` rejects sessions without early access ({@link tmp_earlyAccess}). TODO: remove after GA. */
-  tmp_earlyAccess?: boolean | undefined
 }
 
 /** Authenticated or anonymous caller. */
@@ -229,8 +226,6 @@ export type Variables = {
   principal?: Principal | undefined
   /** Project resolved by {@link ensureProject} for the current request. */
   project?: Projects.Record | undefined
-  /** Temporary early-access gate toggle; unset or false grants everyone early access. TODO: remove after GA. */
-  tmp_earlyAccess?: boolean | undefined
 }
 
 /** Reads the authenticated principal from a Hono context. */
@@ -385,42 +380,6 @@ export function ensureProjectError(c: hono_Context) {
   })
 }
 
-/** Whether the caller can grant early access, independent of the temporary route gate. TODO: remove after GA. */
-export async function tmp_earlyAccessGrant(c: hono_Context): Promise<boolean> {
-  const principal = getPrincipal(c)
-  // Trust chain: `management:write` keys are only mintable by early-access owners.
-  if (principal?.type === 'api_key' || principal?.type === 'super_admin') return true
-  if (principal?.type !== 'session' || !principal.email) return false
-  const email = principal.email.trim().toLowerCase()
-  const db = Db.get(contextDb(c))
-  if (await EarlyAccess.matches(db, email)) return true
-  return Invitations.hasEarlyAccessGrant(db, email)
-}
-
-/** Whether the caller has effective early access, including a dormant temporary gate. TODO: remove after GA. */
-export async function tmp_earlyAccess(c: hono_Context): Promise<boolean> {
-  const enabled = (c.get as (key: string) => unknown)('tmp_earlyAccess') as boolean | undefined
-  if (!enabled) return true
-  return tmp_earlyAccessGrant(c)
-}
-
-/**
- * Always false at runtime, but typed as `boolean` so handlers can include a
- * never-reached early-access-error branch in Hono's inferred response union
- * (the `tmp_earlyAccess` policy flag produces this `403` before the handler
- * runs). TODO: remove after GA.
- */
-export const tmp_narrowEarlyAccess = false as boolean
-
-/** Typed early-access error response for Hono client inference; also the live gate rejection. TODO: remove after GA. */
-export function tmp_ensureEarlyAccessError(c: hono_Context) {
-  return Response.error(c, {
-    code: 'early_access_required',
-    message: 'Requires early access. Ask a teammate with access to invite you by email, or contact Tempo.', // prettier-ignore
-    status: 403,
-  })
-}
-
 /** Reads the caller's membership resolved by the organization or project guard; `undefined` for API keys and `super_admin`. */
 export function membership<environment extends Environment>(
   c: hono_Context<environment>,
@@ -629,9 +588,6 @@ export function middleware<
     if (management && (!auth.mpp || !endpointPolicy.mpp)) return next()
 
     c.set('auth', auth)
-    // Consumed by `tmp_earlyAccess`; absent (or false) leaves the gate dormant.
-    // TODO: remove after GA.
-    c.set('tmp_earlyAccess', options.tmp_earlyAccess)
     return require<environment>(endpointPolicy)(c, next)
   })
 }
@@ -687,12 +643,6 @@ export declare namespace middleware {
      * checks — before the key lookup runs. Omit to disable the entry entirely.
      */
     superAdmin?: { secret: string } | undefined
-    /**
-     * Temporary invite-only gate for routes flagged via {@link policy}.
-     * Allowlist entries live in the `early_access` table (admin dash); unset
-     * grants everyone early access. TODO: remove after GA.
-     */
-    tmp_earlyAccess?: boolean | undefined
   }
 
   /** Resolve-cache tuning for API-key resolution. */
@@ -1196,7 +1146,6 @@ function resolvePolicy(
   let mpp = base.mpp
   let public_ = base.public
   let session = base.session
-  let tmp_earlyAccess = base.tmp_earlyAccess
 
   for (const override of overrides) {
     if (override === false) return undefined
@@ -1205,7 +1154,6 @@ function resolvePolicy(
     mpp = resolveMppLane(mpp, override.mpp, defaults.mpp)
     public_ = resolvePublicLane(public_, override.public, defaults.public)
     session = resolveSessionLane(session, override.session, defaults.session)
-    tmp_earlyAccess = override.tmp_earlyAccess ?? tmp_earlyAccess
   }
 
   // The OpenAPI summary/description rides along as the payment-challenge
@@ -1221,7 +1169,6 @@ function resolvePolicy(
     ...(mpp ? { mpp } : {}),
     ...(public_ ? { public: public_ } : {}),
     ...(session ? { session } : {}),
-    ...(tmp_earlyAccess ? { tmp_earlyAccess } : {}),
   }
 }
 
@@ -1444,12 +1391,6 @@ export function require<environment extends Environment = Environment>(
     )
       return Response.unsupportedChainId(c, chainId, supportedChainIds)
     const proceed = async () => {
-      // Runs after principal resolution, so api_key and super_admin pass by
-      // type; only gated sessions are rejected. TODO: remove after GA.
-      if (policy.tmp_earlyAccess && !(await tmp_earlyAccess(c))) {
-        c.res = tmp_ensureEarlyAccessError(c)
-        return
-      }
       await next()
       // Query credential responses must not enter shared caches.
       const cacheControl = c.res.headers.get('Cache-Control')?.toLowerCase()
@@ -1685,8 +1626,6 @@ export declare namespace require {
       | undefined
     /** Session access policy: `true` allows signed-in wallet sessions. */
     session?: boolean | undefined
-    /** Temporary early-access gate for this route; see {@link tmp_earlyAccess}. TODO: remove after GA. */
-    tmp_earlyAccess?: boolean | undefined
   }
 }
 
@@ -1782,7 +1721,8 @@ function resolveApiKeyLimit(options: resolveApiKeyLimit.Options): RateLimit.Limi
     policy?.rateLimit ?? // 2. route override (protective cap)
     apiKey.rateLimits?.[Scope.wildcard] ?? // 3. per-key default
     auth.apiKey?.rateLimits?.[scope] ?? // 4. config per-scope
-    auth.apiKey?.rateLimits?.[Scope.wildcard] ?? { perMinute: 100 } // 5. config default // 6. hardcoded fallback
+    auth.apiKey?.rateLimits?.[Scope.wildcard] ?? // 5. config default
+    defaultApiKeyRateLimit // 6. hardcoded fallback
   )
 }
 

package/src/internal/EdgeCache.test.ts

@@ -219,7 +219,7 @@ describe('middleware', () => {
 
   test('rechecks route eligibility before every cache lookup', async () => {
     let eligible = true
-    const { app, downstreamCalls, store } = createApp({ eligibility: () => eligible })
+    const { app, downstreamCalls, store } = createApp({ eligibility: [() => eligible] })
 
     await app.request('/cached')
     eligible = false
@@ -229,6 +229,19 @@ describe('middleware', () => {
     expect(store.gets).toBe(1)
     expect(store.size).toBe(1)
   })
+
+  test('requires every route eligibility predicate to permit caching', async () => {
+    const { app, downstreamCalls, store } = createApp({
+      eligibility: [() => true, () => false],
+    })
+
+    await app.request('/cached')
+    await app.request('/cached')
+
+    expect(downstreamCalls()).toBe(2)
+    expect(store.gets).toBe(0)
+    expect(store.size).toBe(0)
+  })
 })
 
 type Environment = { Variables: EdgeCache.Variables }
@@ -263,7 +276,7 @@ function memoryStore() {
 
 function createApp(
   options: {
-    eligibility?: ((c: Context<Environment>) => boolean) | undefined
+    eligibility?: readonly ((c: Context<Environment>) => boolean)[] | undefined
     store?: Store.Store | undefined
   } = {},
 ) {
@@ -282,9 +295,9 @@ function createApp(
   const cacheable_marked = EdgeCache.markCacheable(
     createMiddleware<Environment>(async (_c, next) => next()),
   )
-  const cacheable = options.eligibility
-    ? EdgeCache.setEligibility(cacheable_marked, options.eligibility)
-    : cacheable_marked
+  for (const predicate of options.eligibility ?? [])
+    EdgeCache.setEligibility(cacheable_marked, predicate)
+  const cacheable = cacheable_marked
   app.get('/cached', cacheable, (c) => {
     c.set('edgeCache', { maxAge: 30, staleWhileRevalidate: 300 })
     c.header('Age', '123')

package/src/internal/EdgeCache.ts

@@ -154,12 +154,14 @@ export function markCacheable<const handler extends (...args: never[]) => unknow
   return Object.assign(handler, { [cacheableSymbol]: true })
 }
 
-/** Adds a request eligibility check to a cacheable route handler. */
+/** Adds a request eligibility check; every check must permit caching. */
 export function setEligibility<const handler extends (...args: never[]) => unknown>(
   handler: handler,
   predicate: (c: Context) => boolean,
 ): handler {
-  if (cacheableSymbol in handler) eligibility.set(handler, predicate)
+  const existing = eligibility.get(handler)
+  if (cacheableSymbol in handler)
+    eligibility.set(handler, existing ? (c) => existing(c) && predicate(c) : predicate)
   return handler
 }
 

package/src/internal/FundingQuotes.test.ts

@@ -40,16 +40,29 @@ describe('listQuotes', () => {
     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: {
-        inputAmount: '1000000',
-        minimumOutputAmount: '980000',
-        outputAmount: '990000',
-        outputAmountFormatted: '0.99',
+      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' }])

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) })