tapimo 0.9.0 → 0.10.1

package/src/Webhooks.memory.bench.ts

@@ -0,0 +1,250 @@
+/** @module-tag localnet */
+/**
+ * Measures retained database-factory memory and dense transfer-scan allocations.
+ * Set `WEBHOOK_MEMORY_SNAPSHOT_DIR` to write V8 heap snapshots for retained objects.
+ */
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as v8 from 'node:v8'
+import { nanoid } from 'nanoid'
+import { sendTransactionSync } from 'viem/actions'
+import { Actions, Addresses } from 'viem/tempo'
+import { Webhooks } from 'tapimo'
+import { bench } from 'vite-plus/test'
+
+import * as Db from './db/Db.js'
+import * as Cursor from './internal/Cursor.js'
+import * as Runtime from '../test/runtime.js'
+import * as TestApp from '../test/App.js'
+import * as Tempo from '../test/Tempo.js'
+import * as TestViem from '../test/Viem.js'
+
+const batchSize = 200
+const endOfBlockIndex = 2_147_483_647
+const factoryTicks = positiveInteger('WEBHOOK_MEMORY_FACTORY_TICKS', 25)
+const mebibyte = 1024 * 1024
+const runtime = Runtime.get()
+const transferCallsPerTransaction = 32
+const transferCount = positiveInteger('WEBHOOK_MEMORY_TRANSFER_COUNT', 3_600)
+
+type Memory = {
+  arrayBuffers: number
+  external: number
+  heapUsed: number
+  rss: number
+}
+
+type Report = {
+  after: Memory
+  afterOperation: Memory
+  afterOperationDelta: Memory
+  before: Memory
+  delta: Memory
+  details?: Record<string, number> | undefined
+  label: string
+}
+
+const reports: Report[] = []
+
+beforeAll(() => {
+  if (runtime.mode !== 'localnet')
+    throw new Error('Run webhook memory benchmarks with TEMPO_ENV=localnet.')
+  if (!globalThis.gc)
+    throw new Error('Run webhook memory benchmarks with NODE_OPTIONS=--expose-gc.')
+})
+
+afterAll(() => {
+  process.stdout.write(`WEBHOOK_MEMORY_REPORT ${JSON.stringify(reports)}\n`)
+})
+
+describe('webhook poller memory', () => {
+  bench(
+    `factory-created databases / ${factoryTicks} ticks`,
+    async () => {
+      reports.push(await measureFactoryRetention())
+    },
+    { iterations: 1, time: 0, warmupIterations: 0, warmupTime: 0 },
+  )
+
+  bench(
+    `transfer firehose / ${transferCount} generated transfers`,
+    async () => {
+      reports.push(await measureTransferFirehose())
+    },
+    { iterations: 1, time: 0, warmupIterations: 0, warmupTime: 0 },
+  )
+})
+
+async function measureFactoryRetention(): Promise<Report> {
+  const databases: Db.Db[] = []
+  const schema = `memory_${nanoid()}`
+  const database = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+  await database.migrate()
+  await Webhooks.createSubscription(database, {
+    chainId: runtime.chainId,
+    destination: { type: 'url', url: 'https://hooks.example.com/bench/memory/factory' },
+    eventType: 'block:created',
+    owner: { orgId: 'org_benchmark', type: 'api_key' },
+  })
+  const headBlockNumber = Number(await TestViem.getClient().getBlockNumber())
+  const poller = Webhooks.createPoller({
+    db: () => {
+      const database = Db.postgres({ connectionString: Runtime.postgresUrl, schema })
+      databases.push(database)
+      return database
+    },
+    defaultChainId: runtime.chainId,
+    dispatchBatch: async () => ({ ok: true }),
+    rpc: TestApp.rpc,
+  })
+
+  try {
+    const report = await measure('factory-retained', async () => {
+      for (let index = 0; index < factoryTicks; index++)
+        await poller.tick({
+          confirmations: 0,
+          eventTypes: ['block:created'],
+          headBlockNumber,
+          maxBlocks: 1,
+        })
+    })
+    writeHeapSnapshot('factory-retained')
+    return { ...report, details: { databases: databases.length, ticks: factoryTicks } }
+  } finally {
+    await Promise.allSettled(databases.map((database) => database.close()))
+    await database.close()
+  }
+}
+
+async function measureTransferFirehose(): Promise<Report> {
+  const database = TestApp.database()
+  const client = Tempo.getClient({ account: Tempo.accounts[0] })
+  const startBlockNumber = Number(await TestViem.getClient().getBlockNumber())
+
+  try {
+    for (let offset = 0; offset < transferCount; offset += transferCallsPerTransaction) {
+      const length = Math.min(transferCallsPerTransaction, transferCount - offset)
+      await sendTransactionSync(client, {
+        account: Tempo.accounts[0],
+        calls: Array.from({ length }, () =>
+          Actions.token.transfer.call(client, {
+            amount: 1n,
+            to: Tempo.accounts[1].address,
+            token: Addresses.pathUsd,
+          }),
+        ),
+      })
+    }
+
+    const headBlockNumber = Number(await TestViem.getClient().getBlockNumber())
+    const subscription = await Webhooks.createSubscription(database, {
+      chainId: runtime.chainId,
+      destination: { type: 'url', url: 'https://hooks.example.com/bench/memory/firehose' },
+      eventType: 'token:transfer',
+      filters: {},
+      owner: { orgId: 'org_benchmark', type: 'api_key' },
+    })
+    await Webhooks.setCursor(
+      database,
+      subscription.id,
+      Cursor.encode([startBlockNumber, endOfBlockIndex]),
+    )
+
+    let dispatched = 0
+    let serializedBytes = 0
+    const poller = Webhooks.createPoller({
+      db: database,
+      defaultChainId: runtime.chainId,
+      dispatchBatch: async (dispatchables) => {
+        dispatched += dispatchables.length
+        for (const body of dispatchables)
+          serializedBytes += new TextEncoder().encode(JSON.stringify({ body })).byteLength
+        return { ok: true }
+      },
+      rpc: TestApp.rpc,
+    })
+
+    const report = await measure('transfer-firehose', async () => {
+      const result = await poller.tick({
+        batchSize,
+        confirmations: 0,
+        eventTypes: ['token:transfer'],
+        headBlockNumber,
+        maxBlocks: 500,
+      })
+      if (result.dispatched === 0 || result.dispatched !== dispatched)
+        throw new Error(`Unexpected dispatch count: ${result.dispatched} / ${dispatched}.`)
+      if (result.dispatched > batchSize)
+        throw new Error(`Dispatch count ${result.dispatched} exceeded batch size ${batchSize}.`)
+      if (serializedBytes === 0) throw new Error('Expected serialized webhook queue messages.')
+    })
+    writeHeapSnapshot('transfer-firehose-retained')
+    return {
+      ...report,
+      details: { dispatched, serializedBytes, transferCount },
+    }
+  } finally {
+    await database.close()
+  }
+}
+
+async function measure(label: string, fn: () => Promise<void>): Promise<Report> {
+  collectGarbage()
+  const before = memoryUsage()
+  await fn()
+  const afterOperation = memoryUsage()
+  collectGarbage()
+  const after = memoryUsage()
+  return {
+    after,
+    afterOperation,
+    afterOperationDelta: subtract(afterOperation, before),
+    before,
+    delta: subtract(after, before),
+    label,
+  }
+}
+
+function collectGarbage(): void {
+  globalThis.gc?.()
+  globalThis.gc?.()
+}
+
+function memoryUsage(): Memory {
+  const usage = process.memoryUsage()
+  return {
+    arrayBuffers: mebibytes(usage.arrayBuffers),
+    external: mebibytes(usage.external),
+    heapUsed: mebibytes(usage.heapUsed),
+    rss: mebibytes(usage.rss),
+  }
+}
+
+function mebibytes(bytes: number): number {
+  return Math.round((bytes / mebibyte) * 100) / 100
+}
+
+function positiveInteger(name: string, fallback: number): number {
+  const input = process.env[name]
+  if (!input) return fallback
+  const value = Number(input)
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new Error(`${name} must be a positive integer.`)
+  return value
+}
+
+function subtract(after: Memory, before: Memory): Memory {
+  return {
+    arrayBuffers: after.arrayBuffers - before.arrayBuffers,
+    external: after.external - before.external,
+    heapUsed: after.heapUsed - before.heapUsed,
+    rss: after.rss - before.rss,
+  }
+}
+
+function writeHeapSnapshot(label: string): void {
+  const directory = process.env.WEBHOOK_MEMORY_SNAPSHOT_DIR
+  if (!directory) return
+  fs.mkdirSync(directory, { recursive: true })
+  v8.writeHeapSnapshot(path.join(directory, `${label}.heapsnapshot`))
+}

package/src/Webhooks.test.ts

@@ -1,4 +1,4 @@
-import { Webhooks } from 'tapimo'
+import { Metrics, Webhooks } from 'tapimo'
 import * as TestApp from '../test/App.js'
 
 describe('createPoller', () => {
@@ -25,9 +25,8 @@ describe('createPoller', () => {
 
     // A brand-new subscription anchors at the confirmed head on its first tick
     // (no backfill), so this exercises the createPoller → poll wiring (db
-    // binding, default chain id, injected head, result shape) without touching
-    // TIDX. Detailed poll/getIndexedHead behavior lives in
-    // src/apps/webhooks.test.ts.
+    // binding, default chain id, injected head, and result shape) without an
+    // upstream request. Detailed scanner behavior lives in the route test.
     const result = await poller.tick({ headBlockNumber: 200 })
 
     expect(result).toMatchInlineSnapshot(`
@@ -35,19 +34,70 @@ describe('createPoller', () => {
         "chainId": 42431,
         "dispatched": 0,
         "failed": 0,
-        "safeBlock": 198,
+        "safeBlock": 199,
         "scanned": 0,
         "subscriptions": 1,
       }
     `)
     expect(decodeCursor(await Webhooks.getCursor(db, subscription.id))).toMatchInlineSnapshot(`
       [
-        198,
+        199,
         2147483647,
       ]
     `)
   })
 
+  test('records active subscriptions before scanning', async () => {
+    const db = TestApp.database()
+    await Webhooks.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/x' },
+      eventType: 'block:created',
+      owner: { orgId: 'org_test', type: 'api_key' },
+    })
+    const gauges: { name: string; tags: Metrics.Tags; value: number }[] = []
+    const poller = Webhooks.createPoller({
+      db,
+      defaultChainId: 42431,
+      metrics: Metrics.from({
+        count() {},
+        flush() {},
+        gauge(name, value, tags = {}) {
+          gauges.push({ name, tags, value })
+        },
+        histogram() {},
+      }),
+    })
+
+    await poller.tick({ eventTypes: ['block:created'], headBlockNumber: 200 })
+
+    expect(gauges).toMatchInlineSnapshot(`
+      [
+        {
+          "name": "webhook_poller_active_subscription_count",
+          "tags": {
+            "chain_id": "42431",
+          },
+          "value": 1,
+        },
+        {
+          "name": "webhook_subscription_cursor_lag_blocks",
+          "tags": {
+            "chain_id": "42431",
+          },
+          "value": 0,
+        },
+        {
+          "name": "webhook_poller_safe_block",
+          "tags": {
+            "chain_id": "42431",
+          },
+          "value": 199,
+        },
+      ]
+    `)
+  })
+
   test('clamps a creation checkpoint to genesis', async () => {
     const db = TestApp.database()
     const subscription = await Webhooks.createSubscription(
@@ -72,4 +122,25 @@ describe('createPoller', () => {
 
     expect(decodeCursor(await Webhooks.getCursor(db, subscription.id))).toEqual([0, 2_147_483_647])
   })
+
+  test('keeps a factory-created database open after each tick', async () => {
+    const db = TestApp.database()
+    await Webhooks.createSubscription(db, {
+      chainId: 42431,
+      destination: { type: 'url', url: 'https://hooks.example.com/x' },
+      eventType: 'block:created',
+      owner: { orgId: 'org_test', type: 'api_key' },
+    })
+    const poller = Webhooks.createPoller({
+      db: () => db,
+      defaultChainId: 42431,
+    })
+
+    await poller.tick({
+      eventTypes: ['block:created'],
+      headBlockNumber: 1,
+    })
+
+    await expect(Webhooks.maxCursorBlock(db, 42431)).resolves.toBe(0)
+  })
 })

package/src/Webhooks.ts

@@ -1,11 +1,14 @@
 import * as AppWebhooks from './apps/data/routes/webhooks.js'
 import * as Db from './db/Db.js'
+import * as core_Webhooks from './internal/Webhooks.js'
 import * as MetricSink from './internal/MetricSink.js'
 import * as Store from './internal/Store.js'
 import type * as Metrics from './Metrics.js'
-import * as Tidx from './internal/Tidx.js'
 import * as Viem from './internal/Viem.js'
 
+/** How often a poller reclaims expired rows, independent of tick cadence. */
+const pruneIntervalMs = 60_000
+
 // Re-export the runtime-agnostic primitives (subscriptions, signing, delivery,
 // `deliverAndRecord`, cursors, …) so consumers reach everything through one
 // `Webhooks` namespace. The apps-layer poller stays private behind
@@ -19,33 +22,29 @@ export * from './internal/Webhooks.js'
 export { eventTypes, schema } from './apps/data/routes/webhooks.js'
 
 /**
- * Builds a scheduled webhook poller bound to a state store and chain config.
+ * Builds a webhook poller bound to a state store and chain config.
  *
- * This is the entry point a host runtime drives on a timer (a Cloudflare
- * `scheduled` cron handler, a self-host `setInterval`, …). Each {@link
- * Poller.tick} scans active subscriptions from their cursors up to `head -
- * confirmations` and dispatches matching events.
+ * This is the entry point a host runtime drives from chain-head notifications
+ * or a timer. Each {@link Poller.tick} scans active subscriptions from their
+ * cursors up to `head - confirmations` and dispatches matching events.
  *
- * The monitoring event types (`log:emitted`, `block:created`,
- * `transaction:included`) scan a confirmed window directly over JSON-RPC, so the
- * poller builds memoized viem clients (via {@link Viem.createGetClient}); the legacy
- * `token:transfer` type still reads from TIDX, so it
- * also builds memoized TIDX clients (via {@link Tidx.createGetClient}) when a
- * `tidx` config is supplied. The poller keeps `App.create` a pure Hono app: it
- * constructs its own clients instead of reaching into app internals, and owns no
- * request state.
+ * Every onchain event type scans a confirmed window directly over JSON-RPC, so
+ * the poller builds memoized viem clients via {@link Viem.createGetClient}. The
+ * poller keeps `App.create` a pure Hono app: it constructs its own clients
+ * instead of reaching into app internals, and owns no request state.
  */
 export function createPoller(options: createPoller.Options): createPoller.Poller {
   // Persistent memoize cache for token metadata, shared across ticks (the
   // webhook state store used to double-duty as this cache).
-  const cache = Store.memory()
-  const getTidx = options.tidx
-    ? Tidx.createGetClient({ defaultChainId: options.defaultChainId, tidx: options.tidx })
-    : undefined
+  const cache = options.cache ?? Store.memory()
   const getClient = Viem.createGetClient({
     defaultChainId: options.defaultChainId,
     rpc: options.rpc,
   })
+  // Chain-head ticks run about once per block, so the janitor is throttled here
+  // rather than issuing deletes per block. Reads filter expiry at query time, so
+  // reclaiming late only costs space.
+  let prunedAt: number | undefined
 
   const metrics = options.metrics ? MetricSink.webhooks(options.metrics) : undefined
 
@@ -58,6 +57,8 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
       // returns the underlying result unchanged and is a no-op when no metrics
       // backend is configured.
       const inner = input.dispatch ?? options.dispatch
+      const innerBatch =
+        input.dispatchBatch ?? (input.dispatch === undefined ? options.dispatchBatch : undefined)
       const dispatch =
         metrics && inner
           ? async (dispatchable: AppWebhooks.poll.Dispatchable) => {
@@ -73,8 +74,37 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
               return result
             }
           : inner
+      const dispatchBatch = innerBatch
+        ? async (
+            dispatchables: readonly AppWebhooks.poll.Dispatchable[],
+            context: AppWebhooks.poll.DispatchContext,
+          ) => {
+            const start = Date.now()
+            const result = await innerBatch(dispatchables, context)
+            const durationMs = Date.now() - start
+            for (const dispatchable of dispatchables)
+              metrics?.record({
+                chainId: dispatchable.envelope.chainId,
+                durationMs,
+                eventType: dispatchable.envelope.type,
+                ok: result.ok,
+                type: 'webhook:enqueue',
+              })
+            return result
+          }
+        : undefined
+
+      // Resolve per tick so Workers factories build a fresh Hyperdrive-pooled
+      // connection each run.
+      const db = Db.get(options.db)
+      const now = input.now ?? options.now
+      if (prunedAt === undefined || Date.now() - prunedAt >= pruneIntervalMs) {
+        prunedAt = Date.now()
+        await core_Webhooks.pruneExpired(db, { now }).catch(() => {})
+      }
 
       const start = Date.now()
+      let cursorLagBlocks: number | undefined
       try {
         const result = await AppWebhooks.poll({
           batchSize: input.batchSize ?? options.batchSize,
@@ -82,19 +112,37 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
           chainId,
           client: getClient(chainId),
           confirmations: input.confirmations ?? options.confirmations,
-          // Resolve per tick so Workers factories build a fresh
-          // Hyperdrive-pooled connection each run.
-          db: Db.get(options.db),
+          db,
           dispatch,
+          dispatchBatch,
           eventTypes: input.eventTypes ?? options.eventTypes,
           ...(input.headBlockNumber === undefined
             ? {}
             : { headBlockNumber: input.headBlockNumber }),
           maxBlocks: input.maxBlocks ?? options.maxBlocks,
-          now: input.now ?? options.now,
-          ...(getTidx ? { tidx: getTidx(chainId) } : {}),
+          now,
+          signal: input.signal,
+          ...(metrics
+            ? {
+                onCursorLag(blocks: number) {
+                  cursorLagBlocks = blocks
+                },
+                onScanCheckpoint(checkpoint: AppWebhooks.poll.ScanCheckpoint) {
+                  metrics.record({ chainId, type: 'webhook:poll-scan', ...checkpoint })
+                  // Ship the start boundary before the RPC allocation can terminate the isolate.
+                  metrics.flush()
+                },
+                onStage(stage: AppWebhooks.poll.Stage) {
+                  metrics.record({ chainId, type: 'webhook:poll', ...stage })
+                },
+                onSubscriptions(count: number) {
+                  metrics.record({ chainId, count, type: 'webhook:poll-subscriptions' })
+                },
+              }
+            : {}),
         })
         metrics?.record({
+          cursorLagBlocks,
           meta: { durationMs: Date.now() - start, outcome: 'ok' },
           result,
           type: 'webhook:tick',
@@ -102,6 +150,7 @@ export function createPoller(options: createPoller.Options): createPoller.Poller
         return result
       } catch (error) {
         metrics?.record({
+          cursorLagBlocks,
           meta: { chainId, durationMs: Date.now() - start, outcome: 'error' },
           result: undefined,
           type: 'webhook:tick',
@@ -121,6 +170,9 @@ export declare namespace createPoller {
   /** Delivery transport: hands a matched event to a queue or delivers inline. */
   type Dispatch = NonNullable<AppWebhooks.poll.Options['dispatch']>
 
+  /** Batch delivery transport: confirms all rows together or leaves their cursor unchanged. */
+  type DispatchBatch = NonNullable<AppWebhooks.poll.Options['dispatchBatch']>
+
   /** Summary counters returned by {@link Poller.tick}. */
   type Result = AppWebhooks.poll.Result
 
@@ -128,13 +180,15 @@ export declare namespace createPoller {
   type Defaults = {
     /** Max matching rows scanned per subscription per tick (default 200). */
     batchSize?: number | undefined
-    /** Reorg-safety window: only emit blocks this far behind head (default 2). */
+    /** Reorg-safety window: only emit blocks this far behind head (default 1). */
     confirmations?: number | undefined
     /**
      * Delivery transport. Defaults to inline `deliverAndRecord` (self-host); on
      * Cloudflare pass a Queue producer so retry/backoff/DLQ are native.
      */
     dispatch?: Dispatch | undefined
+    /** Batch delivery transport used when the runtime can enqueue multiple rows atomically. */
+    dispatchBatch?: DispatchBatch | undefined
     /** Event types to poll (default all). */
     eventTypes?: AppWebhooks.poll.Options['eventTypes']
     /** Backfill cap: most blocks an RPC scanner inspects per tick (default 1000). */
@@ -145,16 +199,16 @@ export declare namespace createPoller {
 
   /** Options for {@link createPoller}. */
   type Options = Defaults & {
+    /** Cache for token metadata shared across ticks. */
+    cache?: Store.Store | undefined
     /** Database holding subscriptions + cursors, or a factory resolved per tick (Workers/Hyperdrive). */
     db: Db.Source
     /** Tempo chain id polled when a tick omits one. */
     defaultChainId?: Viem.ChainId | undefined
     /** Metrics backend; emits `webhook:tick` per tick and `webhook:enqueue` per dispatch. */
     metrics?: Metrics.Metrics | undefined
-    /** RPC options for the viem clients the monitoring scanners read from. */
+    /** RPC options for the viem clients that scan chain events. */
     rpc?: Viem.getClient.Rpc | undefined
-    /** TIDX query client options for the legacy `token:transfer` type. */
-    tidx?: Tidx.getClient.Tidx | undefined
   }
 
   /** Per-tick overrides; falls back to the {@link Options} defaults. */
@@ -163,11 +217,13 @@ export declare namespace createPoller {
     chainId?: Viem.ChainId | undefined
     /** Chain head to work back from; resolved from RPC when omitted. */
     headBlockNumber?: bigint | number | undefined
+    /** Stops scanning and dispatch when the caller loses its execution lease. */
+    signal?: AbortSignal | undefined
   }
 
-  /** A scheduled webhook poller. */
+  /** A chain-head-driven webhook poller. */
   type Poller = {
-    /** Runs one poll tick, resolving the indexed head when not supplied. */
+    /** Runs one poll tick, resolving the RPC head when not supplied. */
     tick(options?: TickOptions): Promise<Result>
   }
 }

package/src/admin/apps/api-keys.test.ts

@@ -105,6 +105,15 @@ describe('POST /api-keys', () => {
     expect((await core_ApiKeys.list(store))[0]?.expiresAt).toBe(expiresAt)
   })
 
+  test('rejects an expiry without the minimum storage lead time', async () => {
+    const { client } = await setup()
+    const response = await client['api-keys'].$post({
+      json: { ...validBody, expiresAt: new Date(Date.now() + 60_000).toISOString() },
+    })
+
+    expect(response.status).toBe(400)
+  })
+
   test('rejects an unknown scope with 400', async () => {
     const { client } = await setup()
     const response = await client['api-keys'].$post({

package/src/admin/apps/api-keys.ts

@@ -15,6 +15,9 @@ import type * as App from '../App.js'
 
 /** Zod schemas owned by the admin API-keys handler. */
 export namespace schema {
+  // Leave time for validation and database lookups before KV writes its minimum 60-second TTL.
+  const minimumExpiryLeadMs = 2 * 60_000
+
   const Name = z
     .pipe(
       z.string(),
@@ -27,6 +30,17 @@ export namespace schema {
       z.meta({ examples: ['Explorer testnet'] }),
     )
 
+  const ExpiresAt = z.optional(z.iso.datetime()).check(
+    z.refine(
+      (value) => value === undefined || Date.parse(value) >= Date.now() + minimumExpiryLeadMs,
+      {
+        error: 'Expiry must be at least two minutes in the future.',
+      },
+    ),
+    z.describe('ISO 8601 expiry timestamp. Omit for a non-expiring key.'),
+    z.meta({ examples: ['2100-01-01T00:00:00.000Z'] }),
+  )
+
   const ApiKey = Schema.describe(
     z.extend(ApiKeys.schema.Record, {
       createdByLabel: z
@@ -59,6 +73,7 @@ export namespace schema {
      */
     export const Body = Schema.describe(
       z.extend(z.omit(ApiKeys.schema.MintInput, { createdBy: true, name: true }), {
+        expiresAt: ExpiresAt,
         name: Name,
         scopes: z
           .readonly(

package/src/admin/ui/src/lib/query-client.ts

@@ -17,12 +17,13 @@ const persister = createAsyncStoragePersister({
 })
 
 export const persistOptions: Omit<PersistQueryClientOptions, 'queryClient'> = {
-  maxAge: 1000 * 60 * 60 * 24,
-  persister,
+  buster: 'rate-limit-periods',
   dehydrateOptions: {
     shouldDehydrateQuery: (query) =>
       query.queryKey[0] !== 'config' &&
       query.queryKey[0] !== 'organizations' &&
       defaultShouldDehydrateQuery(query),
   },
+  maxAge: 1000 * 60 * 60 * 24,
+  persister,
 }