tapimo 0.7.1 → 0.7.2

package/src/handlers/relay.ts

@@ -152,7 +152,7 @@ export function relay(options: relay.Options = {}): Handler {
               : undefined
           const externalFeePayerUrl =
             typeof parameters['feePayer'] === 'string'
-              ? normalizeExternalFeePayerUrl(parameters['feePayer'], {
+              ? ExternalFeePayerUrl.normalize(parameters['feePayer'], {
                   allowUnsafe: internal_allowUnsafeUrls,
                 })
               : undefined
@@ -1563,118 +1563,114 @@ function mergeCallsFromRequest(
   return merged
 }
 
-/** Normalizes external fee-payer relay URLs before forwarding fill payloads. */
-function normalizeExternalFeePayerUrl(
-  value: string,
-  options: normalizeExternalFeePayerUrl.Options = {},
-): string {
-  let url: URL
-  try {
-    url = new URL(value)
-  } catch {
-    throw new RpcResponse.InvalidParamsError({ message: 'Invalid fee payer URL.' })
-  }
-
-  const allowUnsafe = options.allowUnsafe === true
-  if (url.protocol !== 'http:' && url.protocol !== 'https:')
-    throw new RpcResponse.InvalidParamsError({ message: 'Invalid fee payer URL protocol.' })
-  if (!allowUnsafe && url.protocol !== 'https:')
-    throw new RpcResponse.InvalidParamsError({ message: 'Invalid fee payer URL protocol.' })
-  if (!allowUnsafe && isUnsafeHostname(url.hostname))
-    throw new RpcResponse.InvalidParamsError({ message: 'Invalid fee payer URL host.' })
-
-  url.username = ''
-  url.password = ''
-  url.hash = ''
-  return url.href
-}
-
-declare namespace normalizeExternalFeePayerUrl {
+namespace ExternalFeePayerUrl {
   type Options = {
     /** Whether to allow non-HTTPS or local/private external fee payer URLs. */
     allowUnsafe?: boolean | undefined
   }
-}
 
-function isUnsafeHostname(hostname: string): boolean {
-  const host = normalizeHostname(hostname)
-  if (host === 'localhost' || host.endsWith('.localhost')) return true
-  const ipv4 = parseIpv4(host)
-  if (ipv4) return isUnsafeIpv4(ipv4)
-  if (!host.includes(':')) return false
-  const ipv6 = parseIpv6(host)
-  if (!ipv6) return true
-  return isUnsafeIpv6(ipv6)
-}
+  /** Normalizes external fee-payer relay URLs before forwarding fill payloads. */
+  export function normalize(value: string, options: Options = {}): string {
+    let url: URL
+    try {
+      url = new URL(value)
+    } catch {
+      throw new RpcResponse.InvalidParamsError({ message: 'Invalid fee payer URL.' })
+    }
 
-function normalizeHostname(hostname: string): string {
-  return hostname
-    .toLowerCase()
-    .replace(/^\[|\]$/g, '')
-    .split('%')[0]!
-}
+    const allowUnsafe = options.allowUnsafe === true
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+      throw new RpcResponse.InvalidParamsError({ message: 'Invalid fee payer URL protocol.' })
+    if (!allowUnsafe && url.protocol !== 'https:')
+      throw new RpcResponse.InvalidParamsError({ message: 'Invalid fee payer URL protocol.' })
+    if (!allowUnsafe && isUnsafeHostname(url.hostname))
+      throw new RpcResponse.InvalidParamsError({ message: 'Invalid fee payer URL host.' })
+
+    url.username = ''
+    url.password = ''
+    url.hash = ''
+    return url.href
+  }
 
-function parseIpv4(value: string): [number, number, number, number] | undefined {
-  const parts = value.split('.')
-  if (parts.length !== 4 || parts.some((part) => !/^\d+$/.test(part))) return undefined
-  const numbers = parts.map((part) => Number(part))
-  if (numbers.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return undefined
-  return numbers as [number, number, number, number]
-}
+  function isUnsafeHostname(hostname: string): boolean {
+    const host = normalizeHostname(hostname)
+    if (host === 'localhost' || host.endsWith('.localhost')) return true
+    const ipv4 = parseIpv4(host)
+    if (ipv4) return isUnsafeIpv4(ipv4)
+    if (!host.includes(':')) return false
+    const ipv6 = parseIpv6(host)
+    if (!ipv6) return true
+    return isUnsafeIpv6(ipv6)
+  }
 
-function isUnsafeIpv4(parts: [number, number, number, number]): boolean {
-  const [a, b] = parts
-  if (a === 0 || a === 10 || a === 127) return true
-  if (a === 100 && b >= 64 && b <= 127) return true
-  if (a === 169 && b === 254) return true
-  if (a === 172 && b >= 16 && b <= 31) return true
-  if (a === 192 && b === 168) return true
-  if (a >= 224) return true
-  return false
-}
+  function normalizeHostname(hostname: string): string {
+    return hostname
+      .toLowerCase()
+      .replace(/^\[|\]$/g, '')
+      .split('%')[0]!
+  }
 
-function parseIpv6(
-  value: string,
-): [number, number, number, number, number, number, number, number] | undefined {
-  const halves = value.split('::')
-  if (halves.length > 2) return undefined
+  function parseIpv4(value: string): [number, number, number, number] | undefined {
+    const parts = value.split('.')
+    if (parts.length !== 4 || parts.some((part) => !/^\d+$/.test(part))) return undefined
+    const numbers = parts.map((part) => Number(part))
+    if (numbers.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return undefined
+    return numbers as [number, number, number, number]
+  }
 
-  const left = halves[0] ? halves[0].split(':') : []
-  const right = halves[1] ? halves[1].split(':') : []
-  const missing = halves.length === 2 ? 8 - left.length - right.length : 0
-  if (missing < 0) return undefined
+  function isUnsafeIpv4(parts: [number, number, number, number]): boolean {
+    const [a, b] = parts
+    if (a === 0 || a === 10 || a === 127) return true
+    if (a === 100 && b >= 64 && b <= 127) return true
+    if (a === 169 && b === 254) return true
+    if (a === 172 && b >= 16 && b <= 31) return true
+    if (a === 192 && b === 168) return true
+    return a >= 224
+  }
 
-  const parts = [...left, ...Array(missing).fill('0'), ...right]
-  if (parts.length !== 8) return undefined
+  function parseIpv6(
+    value: string,
+  ): [number, number, number, number, number, number, number, number] | undefined {
+    const halves = value.split('::')
+    if (halves.length > 2) return undefined
 
-  const numbers = parts.map((part) =>
-    /^[\da-f]{1,4}$/i.test(part) ? Number.parseInt(part, 16) : NaN,
-  )
-  if (numbers.some((part) => !Number.isInteger(part) || part < 0 || part > 0xffff)) return undefined
-  return numbers as [number, number, number, number, number, number, number, number]
-}
+    const left = halves[0] ? halves[0].split(':') : []
+    const right = halves[1] ? halves[1].split(':') : []
+    const missing = halves.length === 2 ? 8 - left.length - right.length : 0
+    if (missing < 0) return undefined
 
-function isUnsafeIpv6(parts: [number, number, number, number, number, number, number, number]) {
-  const [a] = parts
-  if (parts.every((part) => part === 0)) return true
-  if (parts.slice(0, 7).every((part) => part === 0) && parts[7] === 1) return true
-  if ((a & 0xfe00) === 0xfc00) return true
-  if ((a & 0xffc0) === 0xfe80) return true
-  if ((a & 0xffc0) === 0xfec0) return true
-  if ((a & 0xff00) === 0xff00) return true
-
-  const ipv4 = ipv4FromIpv6(parts)
-  if (ipv4) return isUnsafeIpv4(ipv4)
-  return false
-}
+    const parts = [...left, ...Array(missing).fill('0'), ...right]
+    if (parts.length !== 8) return undefined
 
-function ipv4FromIpv6(
-  parts: [number, number, number, number, number, number, number, number],
-): [number, number, number, number] | undefined {
-  const mapped = parts.slice(0, 5).every((part) => part === 0) && parts[5] === 0xffff
-  const compatible = parts.slice(0, 6).every((part) => part === 0)
-  if (!mapped && !compatible) return undefined
-  return [parts[6]! >> 8, parts[6]! & 0xff, parts[7]! >> 8, parts[7]! & 0xff]
+    const numbers = parts.map((part) =>
+      /^[\da-f]{1,4}$/i.test(part) ? Number.parseInt(part, 16) : NaN,
+    )
+    if (numbers.some((part) => !Number.isInteger(part) || part < 0 || part > 0xffff))
+      return undefined
+    return numbers as [number, number, number, number, number, number, number, number]
+  }
+
+  function isUnsafeIpv6(parts: [number, number, number, number, number, number, number, number]) {
+    const [a] = parts
+    if (parts.every((part) => part === 0)) return true
+    if (parts.slice(0, 7).every((part) => part === 0) && parts[7] === 1) return true
+    if ((a & 0xfe00) === 0xfc00) return true
+    if ((a & 0xffc0) === 0xfe80) return true
+    if ((a & 0xffc0) === 0xfec0) return true
+    if ((a & 0xff00) === 0xff00) return true
+
+    const ipv4 = ipv4FromIpv6(parts)
+    return ipv4 ? isUnsafeIpv4(ipv4) : false
+  }
+
+  function ipv4FromIpv6(
+    parts: [number, number, number, number, number, number, number, number],
+  ): [number, number, number, number] | undefined {
+    const mapped = parts.slice(0, 5).every((part) => part === 0) && parts[5] === 0xffff
+    const compatible = parts.slice(0, 6).every((part) => part === 0)
+    if (!mapped && !compatible) return undefined
+    return [parts[6]! >> 8, parts[6]! & 0xff, parts[7]! >> 8, parts[7]! & 0xff]
+  }
 }
 
 /**

package/src/internal/Auth.test.ts

@@ -1889,6 +1889,54 @@ describe('ensureProject', () => {
   })
 })
 
+describe('parseCredential', () => {
+  test('parses credentials keyed by chain id', () => {
+    const credential = Auth.parseCredential(
+      JSON.stringify({ 4217: 'mainnet:secret', 421700001: 'zone:secret' }),
+    )
+
+    expect(credential).toEqual({ 4217: 'mainnet:secret', 421700001: 'zone:secret' })
+  })
+
+  test('supports a shared credential', () => {
+    expect(Auth.parseCredential('shared:secret')).toBe('shared:secret')
+  })
+
+  test('rejects malformed credential maps', () => {
+    expect(() => Auth.parseCredential('{"4217":1}')).toThrowErrorMatchingInlineSnapshot(
+      `[Error: Expected a credential or a chain-id-to-credential JSON object.]`,
+    )
+  })
+})
+
+describe('resolveCredential', () => {
+  test('infers Basic auth from a credential containing a colon', () => {
+    expect(Auth.resolveCredential({ chainId: 4217, value: 'user:password' })).toEqual({
+      basicAuth: 'user:password',
+    })
+  })
+
+  test('infers Bearer auth from a credential without a colon', () => {
+    expect(Auth.resolveCredential({ chainId: 4217, value: 'bearer-token' })).toEqual({
+      basicAuth: undefined,
+      bearerAuth: 'bearer-token',
+    })
+  })
+
+  test('selects a credential by chain id', () => {
+    const value = JSON.stringify({ 4217: 'mainnet:secret', 421700001: 'zone-token' })
+
+    expect(Auth.resolveCredential({ chainId: 4217, value })).toEqual({
+      basicAuth: 'mainnet:secret',
+    })
+    expect(Auth.resolveCredential({ chainId: 421700001, value })).toEqual({
+      basicAuth: undefined,
+      bearerAuth: 'zone-token',
+    })
+    expect(Auth.resolveCredential({ chainId: 42431, value })).toEqual({ basicAuth: undefined })
+  })
+})
+
 function createScopedApp(options: {
   auth?: Auth.Context | undefined
   routes: readonly { path: string; policy: Auth.require.Policy }[]

package/src/internal/Auth.ts

@@ -9,6 +9,7 @@ import { findTargetHandler } from 'hono/utils/handler'
 import { Challenge, Credential, type Method } from 'mppx'
 import { Mppx, tempo } from 'mppx/hono'
 import { Addresses } from 'viem/tempo'
+import { tempoMainnet } from 'viem/tempo/chains'
 import * as z from 'zod/mini'
 
 import type * as App from '../App.js'
@@ -26,7 +27,6 @@ import * as Response from './Response.js'
 import * as Schema from './Schema.js'
 import * as Scope from '../Scope.js'
 import * as Users from '../db/tables/users.js'
-import * as Viem from './Viem.js'
 
 const policySymbol = Symbol('tempo-api.auth.policy')
 const mppManagementSymbol = Symbol('tempo-api.auth.mpp-management')
@@ -1451,7 +1451,7 @@ export function require<environment extends Environment = Environment>(
       if (
         apiKey.environment === 'sandbox' &&
         explicitChain !== undefined &&
-        Viem.isMainnet(explicitChain)
+        explicitChain === tempoMainnet.id
       )
         return jsonError(c, {
           code: 'api_key_forbidden',
@@ -1644,6 +1644,65 @@ type RateLimitAccess = PaymentAccess & {
   rateLimit: RateLimit.Result
 }
 
+/** Shared or per-chain credentials. */
+export type ChainCredential = string | Record<number, string>
+
+/** Parses shared or per-chain credentials from an environment value. */
+export function parseCredential(value: ChainCredential | undefined): parseCredential.ReturnType {
+  if (!value) return undefined
+  if (typeof value !== 'string') return value
+  const credentials = (() => {
+    try {
+      return JSON.parse(value) as unknown
+    } catch {
+      return value
+    }
+  })()
+  if (typeof credentials === 'string') return credentials
+  if (
+    !credentials ||
+    typeof credentials !== 'object' ||
+    Array.isArray(credentials) ||
+    Object.values(credentials).some((credential) => typeof credential !== 'string')
+  )
+    throw new Error('Expected a credential or a chain-id-to-credential JSON object.')
+  return credentials as Record<number, string>
+}
+
+export declare namespace parseCredential {
+  /** Parsed shared or per-chain credentials. */
+  type ReturnType = ChainCredential | undefined
+}
+
+/** Resolves a chain credential and infers its HTTP authorization scheme. */
+export function resolveCredential(
+  options: resolveCredential.Options,
+): resolveCredential.ReturnType {
+  const credentials = parseCredential(options.value)
+  const credential = typeof credentials === 'string' ? credentials : credentials?.[options.chainId]
+  if (!credential) return { basicAuth: undefined }
+  if (credential.includes(':')) return { basicAuth: credential }
+  return { basicAuth: undefined, bearerAuth: credential }
+}
+
+export declare namespace resolveCredential {
+  /** Options for resolving a chain credential. */
+  type Options = {
+    /** Chain id selecting a per-chain credential. */
+    chainId: number
+    /** Shared or per-chain credentials. */
+    value?: ChainCredential | undefined
+  }
+
+  /** Resolved HTTP authorization credentials. */
+  type ReturnType = {
+    /** Basic credentials inferred from a value containing a colon. */
+    basicAuth: string | undefined
+    /** Bearer credential inferred from a value without a colon. */
+    bearerAuth?: string | undefined
+  }
+}
+
 /**
  * How long to wait for the rate-limit counter before failing open. A hot
  * counter backend (e.g. a single Durable Object serving one busy quota bucket)

package/src/internal/Cache.ts

@@ -140,7 +140,7 @@ export function response<environment extends Env>(
     let res = result instanceof Response ? new Response(result.body, result) : c.res
     if (
       result instanceof Response &&
-      etagMatches(res.headers.get('ETag'), c.req.header('If-None-Match'))
+      Etag.matches(res.headers.get('ETag'), c.req.header('If-None-Match'))
     )
       res = notModified(res)
 
@@ -158,7 +158,9 @@ export function response<environment extends Env>(
 
   // `markCacheable` lets the edge layer pay its store lookup only on routes
   // that mount this middleware; everything else skips the read.
-  return EdgeCache.markCacheable(middleware)
+  return EdgeCache.markCacheable(middleware, {
+    key: options.key as (c: Context) => Promise<string> | string,
+  })
 }
 
 export declare namespace response {
@@ -214,9 +216,15 @@ export function urlKey<
   return url.toString()
 }
 
-function etagMatches(etag: string | null, ifNoneMatch: string | undefined) {
-  if (!etag || !ifNoneMatch) return false
-  return ifNoneMatch.split(/,\s*/).some((tag) => stripWeak(tag) === stripWeak(etag))
+namespace Etag {
+  export function matches(etag: string | null, ifNoneMatch: string | undefined) {
+    if (!etag || !ifNoneMatch) return false
+    return ifNoneMatch.split(/,\s*/).some((tag) => stripWeak(tag) === stripWeak(etag))
+  }
+
+  function stripWeak(etag: string) {
+    return etag.replace(/^W\//, '')
+  }
 }
 
 function notModified(response: Response) {
@@ -248,10 +256,6 @@ function setCacheHeaders(
   headers.set('Vary', Array.from(vary.values()).join(', '))
 }
 
-function stripWeak(etag: string) {
-  return etag.replace(/^W\//, '')
-}
-
 // Derive the shared-cache policy from a route's client `Cache-Control`. A
 // positive `s-maxage`/`max-age` (and no `no-store`/`no-cache`) is what makes a
 // route eligible for the anonymous edge cache; the `private` directive only

package/src/internal/Cursor.test.ts

@@ -19,10 +19,10 @@ describe('Cursor', () => {
   })
 
   test('round-trips a timestamp/id tuple', () => {
-    const token = Cursor.encode(['2026-01-01T00:00:00.000Z', 'org_abc123'])
+    const token = Cursor.encode(['2026-01-01T00:00:00.000Z', 'source:transaction-0'])
     expect(Cursor.decode(token, ['timestamp', 'id'])).toEqual([
       '2026-01-01T00:00:00.000Z',
-      'org_abc123',
+      'source:transaction-0',
     ])
   })
 

package/src/internal/Cursor.ts

@@ -138,7 +138,7 @@ function isValid(value: unknown, field: Field): boolean {
     case 'address':
       return typeof value === 'string' && /^0x[0-9a-fA-F]{40}$/.test(value)
     case 'id':
-      return typeof value === 'string' && /^[A-Za-z0-9_-]+$/.test(value)
+      return typeof value === 'string' && /^[A-Za-z0-9:_-]+$/.test(value)
     case 'timestamp':
       return typeof value === 'string' && !Number.isNaN(Date.parse(value))
   }

package/src/internal/EarnRates.test.ts

@@ -0,0 +1,125 @@
+import * as EarnRates from './EarnRates.js'
+
+describe('schema.Window', () => {
+  test('stays absent when omitted', () => {
+    expect(EarnRates.schema.Window.parse(undefined)).toBeUndefined()
+  })
+
+  test('accepts every selectable window and nothing else', () => {
+    expect(
+      ['1h', '1d', '7d', '30d'].map((value) => EarnRates.schema.Window.parse(value)),
+    ).toStrictEqual(['1h', '1d', '7d', '30d'])
+  })
+
+  test('rejects windows outside the selectable set', () => {
+    expect(
+      ['0h', '24h', '36h', '168h', '7x', '1w', '-1d', '1.5d', '721h', '31d', '90d', ''].map(
+        (value) => EarnRates.schema.Window.safeParse(value).success,
+      ),
+    ).toStrictEqual([
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+    ])
+  })
+})
+
+describe('asOf', () => {
+  test('rounds down to a fifteen-minute UTC bucket', () => {
+    vi.useFakeTimers()
+    try {
+      vi.setSystemTime(new Date('2026-07-21T09:14:59.999Z'))
+      const inBucket = EarnRates.asOf()
+      vi.setSystemTime(new Date('2026-07-21T09:29:59.000Z'))
+      expect([inBucket, EarnRates.asOf()]).toMatchInlineSnapshot(`
+        [
+          "2026-07-21T09:00:00.000Z",
+          "2026-07-21T09:15:00.000Z",
+        ]
+      `)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test('withholds the newest thirty seconds', () => {
+    vi.useFakeTimers()
+    try {
+      vi.setSystemTime(new Date('2026-07-21T09:15:20.000Z'))
+      expect(EarnRates.asOf()).toMatchInlineSnapshot(`"2026-07-21T09:00:00.000Z"`)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+describe('annualize', () => {
+  const day = 24 * 60 * 60
+
+  test('annualizes share-price growth over the measured window', () => {
+    expect([
+      EarnRates.annualize({
+        end: { price: 1_010_000n, timestamp: 7 * day },
+        start: { price: 1_000_000n, timestamp: 0 },
+      }),
+      EarnRates.annualize({
+        end: { price: 1_000_500n, timestamp: 30 * day },
+        start: { price: 1_000_000n, timestamp: 0 },
+      }),
+    ]).toMatchInlineSnapshot(`
+      [
+        "0.680075",
+        "0.006100",
+      ]
+    `)
+  })
+
+  test('reports a drawdown as a negative ratio', () => {
+    expect(
+      EarnRates.annualize({
+        end: { price: 990_000n, timestamp: 30 * day },
+        start: { price: 1_000_000n, timestamp: 0 },
+      }),
+    ).toMatchInlineSnapshot(`"-0.115099"`)
+  })
+
+  test('leaves an unmeasurable window unannualized', () => {
+    expect([
+      // Reversed and zero-length windows.
+      EarnRates.annualize({
+        end: { price: 1_000_000n, timestamp: 0 },
+        start: { price: 1_000_000n, timestamp: day },
+      }),
+      EarnRates.annualize({
+        end: { price: 1_000_000n, timestamp: 0 },
+        start: { price: 1_000_000n, timestamp: 0 },
+      }),
+      // A vault with no starting price has no growth to measure.
+      EarnRates.annualize({
+        end: { price: 1_000_000n, timestamp: day },
+        start: { price: 0n, timestamp: 0 },
+      }),
+      // Growth too steep to express as a decimal ratio.
+      EarnRates.annualize({
+        end: { price: 1_010_000n, timestamp: 3600 },
+        start: { price: 1_000_000n, timestamp: 0 },
+      }),
+    ]).toMatchInlineSnapshot(`
+      [
+        null,
+        null,
+        null,
+        null,
+      ]
+    `)
+  })
+})