accounts 0.8.6 → 0.8.8

package/src/server/internal/handlers/relay.ts

@@ -15,15 +15,20 @@ import {
 } from 'viem'
 import type { LocalAccount } from 'viem/accounts'
 import { simulateCalls } from 'viem/actions'
-import { tempo, tempoDevnet, tempoLocalnet, tempoMainnet, tempoModerato } from 'viem/chains'
+import { tempo, tempoDevnet, tempoModerato } from 'viem/chains'
 import { Abis, Actions, Addresses, Capabilities, Transaction } from 'viem/tempo'
 
 import * as ExecutionError from '../../../core/ExecutionError.js'
 import * as Schema from '../../../core/Schema.js'
 import { type Handler, from } from '../../Handler.js'
+import * as Kv from '../../Kv.js'
+import * as Tokenlist from '../tokenlist.js'
 import * as Sponsorship from './sponsorship.js'
 import * as Utils from './utils.js'
 
+/** Default cache TTL in seconds (10 minutes) for the verified tokenlist. */
+const defaultCacheTtl = 10 * 60
+
 /**
  * Instantiates a relay handler that proxies `eth_fillTransaction`
  * with wallet-aware enrichment (fee token resolution, simulation,
@@ -64,16 +69,25 @@ import * as Utils from './utils.js'
  */
 export function relay(options: relay.Options = {}): Handler {
   const {
+    cacheTtl = defaultCacheTtl,
     chains = [tempo, tempoModerato, tempoDevnet],
+    kv = Kv.memory(),
     onRequest,
     path = '/',
-    resolveTokens = (chainId) =>
-      relay.defaultTokens[chainId as keyof typeof relay.defaultTokens] ?? [],
+    resolveTokens,
     transports = {},
     ...rest
   } = options
   const feePayerOptions = options.feePayer
 
+  // Resolves the verified tokenlist for `chainId`, sharing the KV cache with
+  // `Handler.exchange` so a single `kv: Kv.cloudflare(env.KV)` covers both.
+  // The relay only needs addresses, so map down from the full metadata.
+  const getTokens = async (chainId: number): Promise<readonly Address[]> => {
+    const tokens = await Tokenlist.fetch(chainId, kv, { cacheTtl, resolver: resolveTokens })
+    return tokens.map((t) => t.address)
+  }
+
   const features = {
     autoSwap: options.autoSwap ?? options.features === 'all',
     feeTokenResolution: options.resolveTokens ?? options.features === 'all',
@@ -149,16 +163,29 @@ export function relay(options: relay.Options = {}): Handler {
 
           // Lazily resolve a swap source token when autoSwap needs one.
           const resolveFeeTokenForSwap = from
-            ? (insufficientToken: Address) =>
+            ? async (insufficientToken: Address) =>
                 resolveFeeToken(client, {
                   account: from,
                   feeToken: undefined,
-                  tokens: (resolveTokens(chainId) ?? []).filter(
+                  tokens: (await getTokens(chainId)).filter(
                     (t) => t.toLowerCase() !== insufficientToken.toLowerCase(),
                   ),
                 })
             : undefined
 
+          // When no sponsor will pay, prefer fee tokens the user actually
+          // holds. Extend the configured token list with any TIP20 token
+          // the transaction is calling — typically the token being
+          // transferred — so a user transferring USDC.e can pay gas in
+          // USDC.e even when the configured list defaults to pathUSD.
+          const configuredTokens = await getTokens(chainId)
+          const unsponsoredTokens = [
+            ...configuredTokens,
+            ...callTargetTokens(baseTx).filter(
+              (t) => !configuredTokens.some((rt) => rt.toLowerCase() === t.toLowerCase()),
+            ),
+          ]
+
           // When the app provides its own fee payer URL, route the fill
           // through that service so it can sign the transaction.
           const fillClient = externalFeePayerUrl
@@ -205,14 +232,30 @@ export function relay(options: relay.Options = {}): Handler {
               })
               filled = prepared
             } else {
+              // Resolve a fee token for the unsponsored fallback so the
+              // node doesn't pick one the user has zero balance of.
+              const unsponsoredFeeToken = features.feeTokenResolution
+                ? await resolveFeeToken(client, {
+                    account: from,
+                    feeToken: requestFeeToken,
+                    tokens: unsponsoredTokens,
+                  })
+                : requestFeeToken
+              const unsponsoredTx = {
+                ...baseTx,
+                ...(unsponsoredFeeToken ? { feeToken: unsponsoredFeeToken } : {}),
+              }
               const fillOptions = {
                 autoSwap,
-                feeToken,
                 resolveFeeToken: resolveFeeTokenForSwap,
               }
               const [sponsoredFill, unsponsoredFill] = await Promise.all([
-                fill(fillClient, { ...fillOptions, transaction: sponsoredTx }),
-                fill(client, { ...fillOptions, transaction: baseTx }),
+                fill(fillClient, { ...fillOptions, feeToken, transaction: sponsoredTx }),
+                fill(client, {
+                  ...fillOptions,
+                  feeToken: unsponsoredFeeToken,
+                  transaction: unsponsoredTx,
+                }),
               ])
               sponsored = await Sponsorship.shouldSponsor({
                 sender: from,
@@ -220,6 +263,7 @@ export function relay(options: relay.Options = {}): Handler {
                 validate: feePayerOptions!.validate,
               })
               filled = sponsored ? sponsoredFill : unsponsoredFill
+              if (!sponsored) feeToken = unsponsoredFeeToken
             }
           } else {
             // Path C: no sponsorship configured — resolve fee token, fill once.
@@ -227,7 +271,7 @@ export function relay(options: relay.Options = {}): Handler {
               ? await resolveFeeToken(client, {
                   account: from,
                   feeToken: requestFeeToken,
-                  tokens: resolveTokens(chainId),
+                  tokens: unsponsoredTokens,
                 })
               : requestFeeToken
             const transaction = { ...baseTx, ...(feeToken ? { feeToken } : {}) }
@@ -243,7 +287,8 @@ export function relay(options: relay.Options = {}): Handler {
           const swap = 'swap' in filled ? filled.swap : undefined
           if (!feeToken)
             feeToken =
-              (transaction_filled.feeToken as Address | undefined) ?? resolveTokens(chainId)?.[0]
+              (transaction_filled.feeToken as Address | undefined) ??
+              (await getTokens(chainId))[0]
 
           // Parallelize: simulate, fee payer signing, and autoSwap metadata.
           const alreadySigned =
@@ -448,45 +493,6 @@ export function relay(options: relay.Options = {}): Handler {
 }
 
 export namespace relay {
-  /** Default token lists per chain ID for fee token resolution. */
-  // TODO: extract from tokenlist workspace.
-  export const defaultTokens = {
-    [tempoMainnet.id]: [
-      '0x20c0000000000000000000000000000000000000', // pathUSD
-      '0x20c000000000000000000000b9537d11c60e8b50', // USDC.e
-      '0x20c0000000000000000000001621e21f71cf12fb', // EURC.e
-      '0x20c00000000000000000000014f22ca97301eb73', // USDT0
-      '0x20c0000000000000000000003554d28269e0f3c2', // frxUSD
-      '0x20c0000000000000000000000520792dcccccccc', // cUSD
-      '0x20c0000000000000000000008ee4fcff88888888', // stcUSD
-      '0x20c0000000000000000000005c0bac7cef389a11', // GUSD
-      '0x20c0000000000000000000007f7ba549dd0251b9', // rUSD
-      '0x20c000000000000000000000aeed2ec36a54d0e5', // wsrUSD
-      '0x20c0000000000000000000009a4a4b17e0dc6651', // EURAU
-      '0x20c000000000000000000000383a23bacb546ab9', // reUSD
-    ],
-    [tempoModerato.id]: [
-      '0x20c0000000000000000000000000000000000000', // pathUSD
-      '0x20c0000000000000000000000000000000000001', // alphaUSD
-      '0x20c0000000000000000000000000000000000002', // betaUSD
-      '0x20c0000000000000000000000000000000000003', // thetaUSD
-      '0x20c0000000000000000000009e8d7eb59b783726', // USDC.e
-      '0x20c000000000000000000000d72572838bbee59c', // EURC.e
-    ],
-    [tempoDevnet.id]: [
-      '0x20c0000000000000000000000000000000000000', // pathUSD
-      '0x20c0000000000000000000000000000000000001', // alphaUSD
-      '0x20c0000000000000000000000000000000000002', // betaUSD
-      '0x20c0000000000000000000000000000000000003', // thetaUSD
-    ],
-    [tempoLocalnet.id]: [
-      '0x20c0000000000000000000000000000000000000', // pathUSD
-      '0x20c0000000000000000000000000000000000001', // alphaUSD
-      '0x20c0000000000000000000000000000000000002', // betaUSD
-      '0x20c0000000000000000000000000000000000003', // thetaUSD
-    ],
-  } as const
-
   export type Options = from.Options & {
     /**
      * Auto-swap options.
@@ -498,6 +504,11 @@ export namespace relay {
           slippage?: number | undefined
         }
       | undefined
+    /**
+     * TTL in seconds for cached `resolveTokens` results.
+     * @default 600 (10 minutes)
+     */
+    cacheTtl?: number | undefined
     /**
      * Supported chains. The handler resolves the client based on the
      * `chainId` in the incoming transaction.
@@ -526,11 +537,21 @@ export namespace relay {
         }
       | undefined
     /**
-     * Returns token addresses to check balances for during fee token resolution.
-     * The relay checks `balanceOf` for each token and picks the one with the
-     * highest balance.
+     * Kv store used to cache `resolveTokens` results across requests.
+     * Provide `Kv.cloudflare(env.KV)` for cross-instance caching, or omit
+     * for an in-process LRU.
+     * @default Kv.memory()
      */
-    resolveTokens?: ((chainId?: number | undefined) => readonly Address[]) | undefined
+    kv?: Kv.Kv | undefined
+    /**
+     * Resolves the list of known tokens for a chain. The relay checks
+     * `balanceOf` for each token and picks the one with the highest balance
+     * during fee token resolution.
+     * @default Fetches `https://tokenlist.tempo.xyz/list/:chainId`
+     */
+    resolveTokens?:
+      | ((chainId: number) => readonly Tokenlist.Token[] | Promise<readonly Tokenlist.Token[]>)
+      | undefined
     /**
      * Relay features.
      *
@@ -564,6 +585,51 @@ async function fill(
   const format = (value: Record<string, unknown>) =>
     value.type === '0x76' ? value : Utils.formatFillTransactionRequest(client, value)
 
+  // Re-fill the transaction with prepended swap calls so the user can
+  // mint the missing `insufficientToken` (typically the fee token) from
+  // a token they already hold. Returns null if no source token is
+  // available or autoSwap is disabled.
+  async function fillWithSwap(insufficientToken: Address, deficit: bigint) {
+    if (!autoSwap) return null
+    const sourceToken =
+      feeToken && feeToken.toLowerCase() !== insufficientToken.toLowerCase()
+        ? feeToken
+        : await options.resolveFeeToken?.(insufficientToken)
+    if (!sourceToken || sourceToken.toLowerCase() === insufficientToken.toLowerCase()) return null
+
+    const maxAmountIn = deficit + (deficit * BigInt(Math.round(autoSwap.slippage * 1000))) / 1000n
+    const originalCalls = (request.calls as Call[] | undefined) ?? []
+    const swapCalls = buildSwapCalls(sourceToken, insufficientToken, deficit, maxAmountIn)
+
+    const result = await client.request({
+      method: 'eth_fillTransaction',
+      params: [
+        format({
+          ...request,
+          calls: [...swapCalls, ...originalCalls],
+        }) as never,
+      ],
+    })
+    const sponsor = (result as Record<string, any>).capabilities?.sponsor as
+      | { address: Address; name?: string; url?: string }
+      | undefined
+    const mergedTx = mergeCallsFromRequest(result.tx as Record<string, unknown>, {
+      ...request,
+      calls: [...swapCalls, ...originalCalls],
+    })
+    return {
+      transaction: Utils.normalizeTempoTransaction(mergedTx),
+      sponsor,
+      swap: {
+        calls: swapCalls,
+        tokenIn: sourceToken,
+        tokenOut: insufficientToken,
+        amountOut: deficit,
+        maxAmountIn,
+      },
+    }
+  }
+
   try {
     const formatted = format(request)
     const result = await client.request({
@@ -602,6 +668,46 @@ async function fill(
     // them in from the original request before normalizing — otherwise the
     // typed envelope built for sponsorship signing throws CallsEmptyError.
     const mergedTx = mergeCallsFromRequest(result.tx as Record<string, unknown>, request)
+
+    // The node's `eth_fillTransaction` may pick a fee token the user
+    // doesn't yet hold (e.g. one this transaction will mint via a
+    // swap). Tempo's gas check runs before the calls execute, so the
+    // tx would revert at broadcast with `have 0 want N`. Validate the
+    // sender's pre-tx balance against the computed gas cost and, if
+    // short, autoSwap a token they do hold into the fee token.
+    if (autoSwap && !swap) {
+      const fromAddress = request.from as Address | undefined
+      const resolvedFeeToken = ((mergedTx.feeToken as Address | undefined) ?? feeToken) as
+        | Address
+        | undefined
+      const gas = mergedTx.gas ? BigInt(mergedTx.gas as `0x${string}`) : 0n
+      const maxFeePerGas = mergedTx.maxFeePerGas
+        ? BigInt(mergedTx.maxFeePerGas as `0x${string}`)
+        : 0n
+      if (fromAddress && resolvedFeeToken && gas > 0n && maxFeePerGas > 0n) {
+        const [balance, metadata] = await Promise.all([
+          Actions.token
+            .getBalance(client, { account: fromAddress, token: resolvedFeeToken })
+            .catch(() => 0n),
+          resolveTokenMetadata(client, resolvedFeeToken).catch(() => undefined),
+        ])
+        if (metadata) {
+          const requiredFee =
+            (gas * maxFeePerGas) / 10n ** BigInt(Math.max(0, 18 - metadata.decimals))
+          if (balance < requiredFee) {
+            // Best-effort: if the swap itself can't be filled (e.g. the
+            // source token also has insufficient balance), fall through
+            // and return the original tx with the resolved feeToken
+            // rather than failing the whole request.
+            const swapResult = await fillWithSwap(resolvedFeeToken, requiredFee - balance).catch(
+              () => null,
+            )
+            if (swapResult) return swapResult
+          }
+        }
+      }
+    }
+
     return {
       transaction: Utils.normalizeTempoTransaction(mergedTx),
       sponsor,
@@ -617,47 +723,9 @@ async function fill(
     const [available, required, token] = revert.args
     if (typeof available === 'undefined' || typeof required === 'undefined' || !token) throw error
 
-    // Resolve a source token for the swap: use the provided feeToken,
-    // or fall back to resolveFeeToken() to find one the sender holds.
-    const sourceToken =
-      feeToken && feeToken.toLowerCase() !== token.toLowerCase()
-        ? feeToken
-        : await options.resolveFeeToken?.(token as Address)
-    if (!sourceToken || sourceToken.toLowerCase() === token.toLowerCase()) throw error
-
-    const deficit = required - available
-    const maxAmountIn = deficit + (deficit * BigInt(Math.round(autoSwap.slippage * 1000))) / 1000n
-
-    const originalCalls = (request.calls as Call[] | undefined) ?? []
-    const swapCalls = buildSwapCalls(sourceToken, token, deficit, maxAmountIn)
-
-    const result = await client.request({
-      method: 'eth_fillTransaction',
-      params: [
-        format({
-          ...request,
-          calls: [...swapCalls, ...originalCalls],
-        }) as never,
-      ],
-    })
-    const sponsor = (result as Record<string, any>).capabilities?.sponsor as
-      | { address: Address; name?: string; url?: string }
-      | undefined
-    const mergedTx = mergeCallsFromRequest(result.tx as Record<string, unknown>, {
-      ...request,
-      calls: [...swapCalls, ...originalCalls],
-    })
-    return {
-      transaction: Utils.normalizeTempoTransaction(mergedTx),
-      sponsor,
-      swap: {
-        calls: swapCalls,
-        tokenIn: sourceToken,
-        tokenOut: token,
-        amountOut: deficit,
-        maxAmountIn,
-      },
-    }
+    const swapResult = await fillWithSwap(token as Address, required - available)
+    if (!swapResult) throw error
+    return swapResult
   }
 }
 
@@ -713,6 +781,28 @@ async function resolveFeeToken(
   if (best) return best.address
 }
 
+/**
+ * Extracts unique TIP20 token addresses (Tempo `0x20c0…` prefix) that the
+ * transaction's calls target. Used as fallback fee-token candidates so a
+ * user transferring a token they hold can pay gas in that token even when
+ * the configured fee-token list defaults to one they don't hold.
+ */
+function callTargetTokens(transaction: Record<string, unknown>): readonly Address[] {
+  const calls = transaction.calls as readonly { to?: Address }[] | undefined
+  if (!calls) return []
+  const out: Address[] = []
+  const seen = new Set<string>()
+  for (const c of calls) {
+    if (!c.to) continue
+    const lower = c.to.toLowerCase()
+    if (!lower.startsWith('0x20c0')) continue
+    if (seen.has(lower)) continue
+    seen.add(lower)
+    out.push(c.to)
+  }
+  return out
+}
+
 // TODO: cleanup/remove
 function extractCalls(transaction: Record<string, unknown>): readonly Call[] {
   const calls = transaction.calls as readonly Call[] | undefined

package/src/server/internal/kv.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, test } from 'vp/test'
+
+import * as Kv from '../Kv.js'
+import { cached } from './kv.js'
+
+/**
+ * Wraps a memory Kv and records the number of `get`/`set` calls per key —
+ * lets the tests below assert that L1 cache hits short-circuit L2 reads.
+ */
+function counting() {
+  const inner = Kv.memory()
+  const calls = { get: 0, set: 0 }
+  const kv: Kv.Kv = {
+    async get(key) {
+      calls.get++
+      return inner.get(key)
+    },
+    async set(key, value) {
+      calls.set++
+      return inner.set(key, value)
+    },
+    async delete(key) {
+      return inner.delete(key)
+    },
+  }
+  return { calls, kv }
+}
+
+describe('cached', () => {
+  test('behavior: caches the result of fn for the configured ttl', async () => {
+    const { calls, kv } = counting()
+    let invocations = 0
+    const fn = async () => ++invocations
+
+    expect(await cached(kv, 'k', fn, { ttl: 60 })).toBe(1)
+    expect(await cached(kv, 'k', fn, { ttl: 60 })).toBe(1)
+    expect(invocations).toBe(1)
+    // First call writes through to L2; subsequent reads stay in L1.
+    expect(calls.set).toBe(1)
+  })
+
+  test('behavior: re-fetches after the entry expires', async () => {
+    const { kv } = counting()
+    let invocations = 0
+    const fn = async () => ++invocations
+
+    // ttl: 0 expires immediately (Date.now() + 0 is not strictly >).
+    expect(await cached(kv, 'k', fn, { ttl: 0 })).toBe(1)
+    expect(await cached(kv, 'k', fn, { ttl: 0 })).toBe(2)
+    expect(invocations).toBe(2)
+  })
+
+  test('behavior: L1 cache short-circuits L2 reads', async () => {
+    const { calls, kv } = counting()
+    await cached(kv, 'k', async () => 1, { ttl: 60 })
+    expect(calls.get).toBe(1) // miss → reads L2 once
+    await cached(kv, 'k', async () => 2, { ttl: 60 })
+    await cached(kv, 'k', async () => 3, { ttl: 60 })
+    // Subsequent calls hit L1 — no extra L2 reads.
+    expect(calls.get).toBe(1)
+  })
+
+  test('behavior: coalesces concurrent calls for the same key', async () => {
+    const { kv } = counting()
+    let invocations = 0
+    const fn = async () => {
+      invocations++
+      // Force the second call to start before fn() resolves.
+      await new Promise((r) => setTimeout(r, 10))
+      return invocations
+    }
+
+    const [a, b, c] = await Promise.all([
+      cached(kv, 'k', fn, { ttl: 60 }),
+      cached(kv, 'k', fn, { ttl: 60 }),
+      cached(kv, 'k', fn, { ttl: 60 }),
+    ])
+
+    expect(invocations).toBe(1)
+    expect([a, b, c]).toEqual([1, 1, 1])
+  })
+
+  test('behavior: isolates L1 cache per kv instance', async () => {
+    const a = counting()
+    const b = counting()
+    let invocations = 0
+    const fn = async () => ++invocations
+
+    await cached(a.kv, 'k', fn, { ttl: 60 })
+    await cached(b.kv, 'k', fn, { ttl: 60 })
+    expect(invocations).toBe(2)
+  })
+
+  test('behavior: falls back to fn when L2 read throws', async () => {
+    const failing: Kv.Kv = {
+      async get() {
+        throw new Error('boom')
+      },
+      async set() {},
+      async delete() {},
+    }
+
+    expect(await cached(failing, 'k', async () => 'value', { ttl: 60 })).toBe('value')
+  })
+
+  test('behavior: does not throw when L2 write fails', async () => {
+    const failing: Kv.Kv = {
+      async get() {
+        return null as never
+      },
+      async set() {
+        throw new Error('boom')
+      },
+      async delete() {},
+    }
+
+    expect(await cached(failing, 'k', async () => 'value', { ttl: 60 })).toBe('value')
+  })
+
+  test('behavior: caches forever when ttl is omitted', async () => {
+    const { kv } = counting()
+    let invocations = 0
+    const fn = async () => ++invocations
+
+    expect(await cached(kv, 'k', fn)).toBe(1)
+    expect(await cached(kv, 'k', fn)).toBe(1)
+    expect(invocations).toBe(1)
+  })
+})

package/src/server/internal/kv.ts

@@ -1,10 +1,33 @@
 import type * as Kv from '../Kv.js'
 
+type Entry = { expiresAt: number; value: unknown }
+
+/**
+ * Per-`kv`-instance in-memory L1 cache. Lives for the lifetime of the worker
+ * (or process) and short-circuits the L2 `kv.get` on hot keys so a request
+ * with N callers that share the same `cached()` key only pays for one
+ * remote read.
+ *
+ * `WeakMap` keys mean dropping a `kv` reference releases its L1 entries
+ * automatically — no need to thread a lifecycle hook through callers.
+ */
+const memoryStore = new WeakMap<Kv.Kv, Map<string, Entry>>()
+
 /**
- * Reads `key` from `kv`. If absent or expired, calls `fn`, stores the result
- * with a `Date.now() + ttl * 1000` expiry, and returns it. Defaults to
- * caching forever (no expiry). Kv read/write failures are swallowed so cache
- * misses never break the caller.
+ * Per-`kv`-instance in-flight dedupe table. Multiple concurrent
+ * `cached(kv, key, fn)` calls for the same key share a single `fn()`
+ * invocation instead of stampeding the upstream.
+ */
+const inflightStore = new WeakMap<Kv.Kv, Map<string, Promise<unknown>>>()
+
+/**
+ * Reads `key` from a two-tier cache (in-memory L1, `kv`-backed L2). If absent
+ * or expired in both tiers, calls `fn`, stores the result with a
+ * `Date.now() + ttl * 1000` expiry in both tiers, and returns it. Defaults
+ * to caching forever (no expiry). Kv read/write failures are swallowed so
+ * cache misses never break the caller.
+ *
+ * Concurrent calls for the same key share a single `fn()` invocation.
  */
 export async function cached<value>(
   kv: Kv.Kv,
@@ -14,13 +37,38 @@ export async function cached<value>(
 ): Promise<value> {
   const { ttl = Infinity } = options
 
-  const entry = await kv.get<{ expiresAt: number; value: value } | null>(key).catch(() => null)
-  if (entry && entry.expiresAt > Date.now()) return entry.value
+  // L1: in-memory.
+  const memory = memoryFor(kv)
+  const local = memory.get(key)
+  if (local && local.expiresAt > Date.now()) return local.value as value
+
+  // Coalesce concurrent calls for the same key.
+  const inflight = inflightFor(kv)
+  const pending = inflight.get(key) as Promise<value> | undefined
+  if (pending) return pending
 
-  const value = await fn()
-  const expiresAt = ttl === Infinity ? Infinity : Date.now() + ttl * 1000
-  await kv.set(key, { expiresAt, value }).catch(() => {})
-  return value
+  const promise = (async () => {
+    // L2: kv.
+    const entry = await kv.get<Entry | null>(key).catch(() => null)
+    if (entry && entry.expiresAt > Date.now()) {
+      memory.set(key, entry)
+      return entry.value as value
+    }
+
+    const value = await fn()
+    const expiresAt = ttl === Infinity ? Infinity : Date.now() + ttl * 1000
+    const fresh: Entry = { expiresAt, value }
+    memory.set(key, fresh)
+    await kv.set(key, fresh).catch(() => {})
+    return value
+  })()
+
+  inflight.set(key, promise)
+  try {
+    return await promise
+  } finally {
+    inflight.delete(key)
+  }
 }
 
 export declare namespace cached {
@@ -33,3 +81,21 @@ export declare namespace cached {
     ttl?: number | undefined
   }
 }
+
+function memoryFor(kv: Kv.Kv) {
+  let map = memoryStore.get(kv)
+  if (!map) {
+    map = new Map()
+    memoryStore.set(kv, map)
+  }
+  return map
+}
+
+function inflightFor(kv: Kv.Kv) {
+  let map = inflightStore.get(kv)
+  if (!map) {
+    map = new Map()
+    inflightStore.set(kv, map)
+  }
+  return map
+}