tapimo 0.4.1 → 0.4.4

package/src/internal/FundingRoutes.test.ts

@@ -2,7 +2,7 @@ import * as FundingRoutes from './FundingRoutes.js'
 
 const baseUsdcRequest = {
   limit: 10,
-  provider: 'across',
+  provider: 'relay',
   sourceAmount: '1000000',
   sourceAmountUnits: 'baseUnits',
   sourceChain: 'base',
@@ -15,7 +15,7 @@ describe('listRoutes', () => {
     const routes = await FundingRoutes.listRoutes({
       ...baseUsdcRequest,
       adapters: {
-        across: {
+        relay: {
           async probeQuote(input, signal) {
             seen = input
             expect(signal.aborted).toBe(false)
@@ -53,14 +53,14 @@ describe('listRoutes', () => {
       },
     })
 
-    expect(seen?.route.id).toBe('base-usdc-tempo-usdce-across')
+    expect(seen?.route.id).toBe('base-usdc-tempo-usdce-relay')
     expect(seen?.sourceAmount.amount).toBe('1000000')
     expect(seen?.sourceChain.id).toBe('eip155:8453')
     expect(seen?.sourceToken.symbol).toBe('USDC')
     expect(routes).toHaveLength(1)
     expect(routes[0]).toMatchObject({
       errorCode: null,
-      id: 'base-usdc-tempo-usdce-across',
+      id: 'base-usdc-tempo-usdce-relay',
       quality: {
         availableVolumeUsd: '1000.00',
         estimatedSeconds: 4,
@@ -94,7 +94,7 @@ describe('listRoutes', () => {
     const routes = await FundingRoutes.listRoutes({
       ...baseUsdcRequest,
       adapters: {
-        relay: {
+        bridge: {
           async probeQuote() {
             calls += 1
             throw new Error('unexpected call')
@@ -119,7 +119,7 @@ describe('listRoutes', () => {
     const routes = await FundingRoutes.listRoutes({
       ...baseUsdcRequest,
       adapters: {
-        across: {
+        relay: {
           async probeQuote() {
             throw new Error('upstream unavailable')
           },
@@ -145,7 +145,7 @@ describe('listRoutes', () => {
       ...baseUsdcRequest,
       adapterTimeoutMs: 1,
       adapters: {
-        across: {
+        relay: {
           probeQuote(_input, signal) {
             signal.addEventListener('abort', () => {
               aborted = true
@@ -174,7 +174,7 @@ describe('listRoutes', () => {
     const routes = await FundingRoutes.listRoutes({
       ...baseUsdcRequest,
       adapters: {
-        across: {
+        relay: {
           async probeQuote(input) {
             seen = input
             return {

package/src/internal/FundingRoutes.ts

@@ -18,7 +18,6 @@ const sourceChains = [
     kind: 'evm',
     name: 'Ethereum',
     providerIds: {
-      across: '1',
       bridge: 'ethereum',
       bungee: '1',
       lifi: '1',
@@ -75,7 +74,6 @@ const sourceChains = [
     kind: 'evm',
     name: 'Base',
     providerIds: {
-      across: '8453',
       bridge: 'base',
       bungee: '8453',
       lifi: '8453',
@@ -116,7 +114,6 @@ const sourceChains = [
     kind: 'evm',
     name: 'BNB Smart Chain',
     providerIds: {
-      across: '56',
       bungee: '56',
       lifi: '56',
       relay: '56',
@@ -241,14 +238,6 @@ const destinationTokens = [
 
 /** Providers exposed by the generic provider catalog. */
 const providers = [
-  {
-    capabilities: ['fundingRoutes'],
-    id: 'across',
-    kind: 'intentBridge',
-    name: 'Across',
-    requiresApiKey: true,
-    status: 'inventoryOnly',
-  },
   {
     capabilities: ['fundingRoutes'],
     id: 'relay',
@@ -307,7 +296,9 @@ export type ChainRef = ReturnType<typeof formatChain> | typeof destinationChain
 export type TokenAmount = ReturnType<typeof resolveSourceAmount>
 
 /** Normalized token reference passed to provider adapters. */
-export type TokenRef = ReturnType<typeof formatDestinationToken> | ReturnType<typeof formatSourceToken>
+export type TokenRef =
+  | ReturnType<typeof formatDestinationToken>
+  | ReturnType<typeof formatSourceToken>
 
 /** A normalized funding route candidate returned by route discovery. */
 export type RouteCandidate = ReturnType<typeof formatRouteCandidate>
@@ -422,7 +413,6 @@ export type ProviderAdapters = Partial<Record<ProviderId, ProviderAdapter>>
 
 /** Static provider support rows used until live quote adapters are configured. */
 const inventory: readonly InventoryEntry[] = [
-  { destinationToken: 'usdce', provider: 'across', sourceChains: ['ethereum', 'base', 'bnb'], sourceTokens: ['USDC'] }, // prettier-ignore
   { destinationToken: 'usdce', provider: 'relay', sourceChains: ['ethereum', 'base', 'bnb'], sourceTokens: ['USDC', 'USDT'] }, // prettier-ignore
   { destinationToken: 'usdce', provider: 'bridge', sourceChains: ['ethereum', 'base', 'solana'], sourceTokens: ['USDC'] }, // prettier-ignore
   { destinationToken: 'usdce', provider: 'bridge', sourceChains: ['ethereum', 'solana', 'tron'], sourceTokens: ['USDT'] }, // prettier-ignore
@@ -472,7 +462,10 @@ export declare namespace listProviders {
 /** Parses the comma-separated `include` query parameter. */
 export function parseInclude(input: string | undefined) {
   if (input === undefined || input.trim() === '') return []
-  const parsed = input.split(',').map((part) => part.trim()).filter(Boolean)
+  const parsed = input
+    .split(',')
+    .map((part) => part.trim())
+    .filter(Boolean)
   for (const include of parsed)
     if (!(includes as readonly string[]).includes(include)) throw new UnsupportedIncludeError()
   return [...new Set(parsed)] as readonly Include[]
@@ -608,19 +601,22 @@ async function enrichRoute(
   if (!adapter) return route
 
   try {
-    const quote = await quoteWithTimeout(
-      adapter,
-      {
-        cache: options.cache,
-        destinationChain: route.destinationChain,
-        destinationToken: route.destinationToken,
-        include: options.include,
-        request: options.request,
-        route,
-        sourceAmount: route.sourceAmount,
-        sourceChain: route.sourceChain,
-        sourceToken: route.sourceToken,
-      },
+    const quote = await runWithTimeout(
+      (signal) =>
+        adapter.probeQuote(
+          {
+            cache: options.cache,
+            destinationChain: route.destinationChain,
+            destinationToken: route.destinationToken,
+            include: options.include,
+            request: options.request,
+            route,
+            sourceAmount: route.sourceAmount,
+            sourceChain: route.sourceChain,
+            sourceToken: route.sourceToken,
+          },
+          signal,
+        ),
       options.timeoutMs,
     )
     return {
@@ -770,11 +766,11 @@ function markRouteError(route: RouteCandidate, errorCode: string) {
   }
 }
 
-function quoteWithTimeout(adapter: ProviderAdapter, input: QuoteProbeInput, timeoutMs: number) {
+function runWithTimeout<result>(fn: (signal: AbortSignal) => Promise<result>, timeoutMs: number) {
   const controller = new AbortController()
   const timeout = setTimeout(() => controller.abort(), timeoutMs)
   return Promise.race([
-    adapter.probeQuote(input, controller.signal),
+    fn(controller.signal),
     new Promise<never>((_, reject) => {
       if (controller.signal.aborted) {
         reject(new ProviderAdapterTimeoutError())

package/src/internal/Log.test.ts

@@ -65,8 +65,7 @@ describe('middleware', () => {
     })
     api.get('/secure', (c) => c.json({ ok: true }, 200))
 
-    const token = `tempo:sk:${'a'.repeat(48)}`
-    await api.request(`/secure?apiKey=${token}`)
+    await api.request('/secure?key=opaque-secret&chainId=mainnet')
 
     expect(stable(entries[0]!)).toMatchInlineSnapshot(`
       {
@@ -80,7 +79,7 @@ describe('middleware', () => {
           "orgId": "org_1",
           "type": "api_key",
         },
-        "query": "apiKey=tempo:sk:…",
+        "query": "chainId=mainnet",
         "route": "/secure",
         "status": 200,
       }
@@ -139,6 +138,45 @@ describe('middleware', () => {
     `)
   })
 
+  test('includes redacted provider failure details', async () => {
+    const entries: Log.Entry[] = []
+    const api = app({ emit: (entry) => void entries.push(entry) })
+    api.get('/provider', (c) => {
+      c.set('providerFailure', {
+        code: 'UNAUTHORIZED',
+        failure: 'http',
+        id: 'relay',
+        operation: 'quote/v2',
+        status: 401,
+      })
+      return Response.error(c, {
+        code: 'provider_error',
+        message: 'Provider request failed',
+        status: 502,
+      })
+    })
+
+    await api.request('/provider')
+
+    expect(stable(entries[0]!)).toMatchInlineSnapshot(`
+      {
+        "errorCode": "provider_error",
+        "level": "error",
+        "method": "GET",
+        "path": "/provider",
+        "provider": {
+          "code": "UNAUTHORIZED",
+          "failure": "http",
+          "id": "relay",
+          "operation": "quote/v2",
+          "status": 401,
+        },
+        "route": "/provider",
+        "status": 502,
+      }
+    `)
+  })
+
   test('logs thrown errors at error level', async () => {
     const entries: Log.Entry[] = []
     const api = app({ emit: (entry) => void entries.push(entry) })

package/src/internal/Log.ts

@@ -10,6 +10,8 @@ import type * as Timing from './Timing.js'
 export type Variables = {
   /** Stable error code recorded by `Response.error` for the request log entry. */
   errorCode?: string | undefined
+  /** Redacted provider failure details recorded by an upstream adapter. */
+  providerFailure?: Entry['provider'] | undefined
 }
 
 /** Hono environment shape used by the request logger. */
@@ -55,12 +57,27 @@ export type Entry = {
         id: string
         /** Owning organization id for API-key callers. */
         orgId?: string | undefined
-        /** Owning project id for project-attributed API-key callers. */
+        /** Attributed project id for API-key callers. */
         projectId?: string | undefined
         /** Principal kind. */
         type: 'api_key' | 'public' | 'session' | 'super_admin'
       }
     | undefined
+  /** Redacted upstream provider failure details, when an adapter request fails. */
+  provider?:
+    | {
+        /** Stable provider error code, when one is safe to retain. */
+        code?: string | undefined
+        /** Failure boundary that rejected the provider request. */
+        failure: 'http' | 'network' | 'payload' | 'unknown'
+        /** Provider identifier. */
+        id: string
+        /** Provider operation identifier. */
+        operation: string
+        /** Upstream HTTP status, when a response was received. */
+        status?: number | undefined
+      }
+    | undefined
   /** Raw query string (no leading `?`) with API-key tokens redacted, when present. */
   query?: string | undefined
   /** Rate limit state from the `RateLimit-*` response headers, when enforced. */
@@ -110,12 +127,15 @@ export function middleware<environment extends Environment = Environment>(
     const duration = performance.now() - start
 
     const url = new URL(c.req.url)
+    url.searchParams.delete('key')
+    const query = ApiKey.redact(url.search.slice(1))
     const status = c.res.status
     // Hono cannot resolve variable types through the generic `environment`,
     // so shared-variable reads are cast from the environment contract above
     // (the same pattern EdgeCache uses for its cross-layer reads).
     const principal = c.get('principal' as never) as Auth.Principal | undefined
     const errorCode = c.get('errorCode' as never) as string | undefined
+    const provider = c.get('providerFailure' as never) as Entry['provider']
 
     // The `request` total metric duplicates `duration` (measured here, one
     // layer further out), so only operation timings are kept.
@@ -165,9 +185,8 @@ export function middleware<environment extends Environment = Environment>(
               type: principal.type,
             },
           }),
-      // Keys belong in headers, but a confused client may pass one in the
-      // query string; redact defensively before it reaches a log store.
-      ...(url.search.length > 1 ? { query: ApiKey.redact(url.search.slice(1)) } : {}),
+      ...(provider === undefined ? {} : { provider }),
+      ...(query ? { query } : {}),
       ...(rateLimit === undefined ? {} : { rateLimit }),
       requestId: c.get('requestId' as never) as string,
       route: c.req.routePath,

package/src/internal/Store.test-d.ts

@@ -0,0 +1,15 @@
+import type { Store as MppStore } from 'mppx'
+import { Store } from 'tapimo'
+
+declare const namespace: Store.durableObject.Namespace
+
+type Items = {
+  channel: { spent: bigint }
+}
+
+describe('durableObject', () => {
+  test('matches typed atomic stores', () => {
+    expectTypeOf(Store.durableObject(namespace)).toExtend<MppStore.AtomicStore<Items>>()
+    expectTypeOf(Store.durableObject<Items>(namespace)).toEqualTypeOf<Store.AtomicState<Items>>()
+  })
+})

package/src/internal/Store.test.ts

@@ -1,4 +1,5 @@
 import { Store } from 'tapimo'
+import * as TestStore from '../../test/Store.js'
 
 describe('from', () => {
   const ops = {
@@ -327,16 +328,162 @@ describe('cloudflareKv', () => {
 })
 
 describe('durableObject', () => {
-  // The stub contract requires native `increment` and `swap` (our DO class
-  // implements them); derive them for the in-memory fakes.
+  type TypedItems = {
+    channel: { spent: bigint }
+    other: bigint
+  }
+
+  // Derive native RPC operations for in-memory fakes.
   function stubFor(backing: Store.State): Store.durableObject.Stub {
     return {
       ...backing,
+      deleteIf: (key, expected) => backing.deleteIf!(key, expected),
       increment: (key, options) => Store.increment(backing, key, options),
       swap: (key, expected, next, options) => backing.swap!(key, expected, next, options),
     }
   }
 
+  test('supports typed values with per-key sharding by default', async () => {
+    const { names, namespace } = TestStore.durableObjectNamespace()
+    const storeA = Store.durableObject<TypedItems>(namespace)
+    const storeB = Store.durableObject<TypedItems>(namespace)
+
+    await storeA.put('channel', { spent: 42n })
+    await storeA.put('other', 7n)
+
+    expect(await storeB.get('channel')).toMatchInlineSnapshot(`
+      {
+        "spent": 42n,
+      }
+    `)
+    expect([...new Set(names)]).toMatchInlineSnapshot(`
+      [
+        "channel",
+        "other",
+      ]
+    `)
+  })
+
+  test('keeps typed updates linearizable', async () => {
+    const { namespace } = TestStore.durableObjectNamespace()
+    const storeA = Store.durableObject<TypedItems>(namespace)
+    const storeB = Store.durableObject<TypedItems>(namespace)
+    await storeA.put('channel', { spent: 0n })
+
+    for (let index = 0; index < 20; index++)
+      await Promise.all([
+        storeA.update('channel', (current) => ({
+          op: 'set',
+          result: undefined,
+          value: { spent: (current?.spent ?? 0n) + 1n },
+        })),
+        storeB.update('channel', (current) => ({
+          op: 'set',
+          result: undefined,
+          value: { spent: (current?.spent ?? 0n) + 1n },
+        })),
+      ])
+
+    expect(await storeA.get('channel')).toMatchInlineSnapshot(`
+      {
+        "spent": 40n,
+      }
+    `)
+  })
+
+  test('supports no-op and delete update results', async () => {
+    const { getState, namespace } = TestStore.durableObjectNamespace()
+    const store = Store.durableObject<TypedItems>(namespace)
+    await store.put('channel', { spent: 42n })
+
+    const unchanged = await store.update('channel', (current) => ({
+      op: 'noop',
+      result: current?.spent,
+    }))
+    const deleted = await store.update('channel', () => ({ op: 'delete', result: 'deleted' }))
+
+    expect(unchanged).toMatchInlineSnapshot(`42n`)
+    expect(deleted).toMatchInlineSnapshot(`"deleted"`)
+    expect(await store.get('channel')).toBeNull()
+    expect(await getState('channel').list()).toMatchInlineSnapshot(`
+      {
+        "keys": [],
+      }
+    `)
+  })
+
+  test('rejects typed values written with an unknown codec version', async () => {
+    const { getState, namespace } = TestStore.durableObjectNamespace()
+    await getState('channel').put('channel', 'tempo-api:store:json:v2:{}')
+    const store = Store.durableObject<TypedItems>(namespace)
+
+    await expect(store.get('channel')).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Store.DurableObjectCodecError: Unsupported Durable Object store codec version: v2]`,
+    )
+  })
+
+  test('bounds typed update contention', async () => {
+    const backing = Store.memory()
+    const namespace = {
+      getByName() {
+        return { ...stubFor(backing), swap: async () => false }
+      },
+    } satisfies Store.durableObject.Namespace
+    const store = Store.durableObject<{ channel: bigint }>(namespace)
+    let updates = 0
+
+    await expect(
+      store.update('channel', () => {
+        updates += 1
+        return { op: 'set', result: undefined, value: 1n }
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Store.UpdateContentionError: Store update on "channel" lost 8 compare-and-swap attempts.]`,
+    )
+    expect(updates).toMatchInlineSnapshot(`8`)
+  })
+
+  test('does not retry ambiguous typed update writes', async () => {
+    const backing = Store.memory()
+    let swaps = 0
+    const namespace = {
+      getByName() {
+        return {
+          ...stubFor(backing),
+          swap() {
+            swaps += 1
+            throw Object.assign(new Error('Network connection lost.'), { retryable: true })
+          },
+        }
+      },
+    } satisfies Store.durableObject.Namespace
+    const store = Store.durableObject<{ channel: bigint }>(namespace)
+
+    await expect(
+      store.update('channel', () => ({ op: 'set', result: undefined, value: 1n })),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(`[Error: Network connection lost.]`)
+    expect(swaps).toMatchInlineSnapshot(`1`)
+  })
+
+  test('round trips strings that use the codec namespace', async () => {
+    const { namespace } = TestStore.durableObjectNamespace()
+    const store = Store.durableObject(namespace)
+    const value = 'tempo-api:store:json:v2:not-a-cell'
+
+    await store.put('key', value)
+
+    expect(await store.get<string>('key')).toBe(value)
+  })
+
+  test('rejects unserializable typed values', async () => {
+    const { namespace } = TestStore.durableObjectNamespace()
+    const store = Store.durableObject(namespace)
+
+    await expect(store.put('invalid', undefined)).rejects.toThrow(
+      'Durable Object store value is not serializable',
+    )
+  })
+
   test('adapts a Durable Object namespace without caching stubs', async () => {
     const calls: string[] = []
     const backing = Store.memory({
@@ -385,6 +532,7 @@ describe('durableObject', () => {
         objects.set(name, backing)
         const stub = {
           delete: (key) => backing.delete(key),
+          deleteIf: (key, expected) => backing.deleteIf!(key, expected),
           get: (key) => backing.get(key),
           increment: (key, options) => Store.increment(backing, key, options),
           list: (options) => backing.list(options),
@@ -541,6 +689,9 @@ describe('durableObject', () => {
         ],
       }
     `)
+    expect(await store.deleteIf!('secret:2', 'wrong')).toBe(false)
+    expect(await store.deleteIf!('secret:2', 'beta')).toBe(true)
+    expect(await store.get('secret:2')).toBeNull()
     expect(storage.cells.has('secret:1')).toMatchInlineSnapshot(`false`)
   })
 })