tapimo 0.7.0 → 0.7.2

package/src/apps/data/routes/zones.ts

@@ -0,0 +1,338 @@
+import { Hono } from 'hono'
+import { AbiEvent, AbiFunction, type Hex } from 'ox'
+import * as z from 'zod/mini'
+
+import type * as App from '../../../App.js'
+import * as Auth from '../../../internal/Auth.js'
+import * as Cache from '../../../internal/Cache.js'
+import * as OpenApi from '../../../internal/OpenApi.js'
+import * as Response from '../../../internal/Response.js'
+import * as Schema from '../../../internal/Schema.js'
+import * as Timing from '../../../internal/Timing.js'
+import * as Value from '../../../internal/Value.js'
+
+const exampleSenderTag = '0x61fc42a734cb44acef497ea0bed612c691195623244136e0739e1929569e2487'
+const exampleTransactionHash = '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665'
+const exampleWithdrawalId = `${exampleTransactionHash}-4`
+
+const withdrawalProcessedEvent = AbiEvent.from(
+  'event WithdrawalProcessed(address indexed to, bytes32 indexed senderTag, address token, uint128 amount, bool callbackSuccess)',
+)
+const withdrawalProcessedSelector = AbiEvent.getSelector(withdrawalProcessedEvent)
+const lastSyncedTempoBlockNumberFunction = AbiFunction.from(
+  'function lastSyncedTempoBlockNumber() view returns (uint64)',
+)
+
+/** Zod schemas owned by Zone handlers. */
+export namespace schema {
+  /** Schemas for the listZoneWithdrawals operation. */
+  export namespace listZoneWithdrawals {
+    /** Path parameters for a Zone withdrawal list request. */
+    export const Params = z
+      .object({
+        senderTag: Schema.hash(exampleSenderTag).check(
+          z.describe(
+            'The 32-byte correlation tag shared by withdrawals from one sender in one Zone transaction.',
+          ),
+        ),
+      })
+      .check(z.describe('Path parameters used to correlate Zone withdrawals.'))
+
+    /** Query parameters for a Zone withdrawal list request. */
+    export const Query = z
+      .strictObject({
+        chainId: Schema.ChainId.check(
+          z.describe('The chain id of the Zone where the withdrawal originated.'),
+          z.meta({ examples: [421_700_001] }),
+        ),
+      })
+      .check(z.describe('Query parameters used to select the originating Zone.'))
+
+    /** Indexed Zone withdrawal after parent-chain processing. */
+    export const Withdrawal = z
+      .object({
+        blockNumber: z
+          .number()
+          .check(
+            z.int(),
+            z.nonnegative(),
+            z.describe('Parent-chain block containing the withdrawal processing event.'),
+            z.meta({ examples: [123] }),
+          ),
+        id: z
+          .string()
+          .check(
+            z.describe(
+              'Stable withdrawal id built from the parent transaction hash and log index (`${transactionHash}-${logIndex}`).',
+            ),
+            z.meta({ examples: [exampleWithdrawalId] }),
+          ),
+        logIndex: z
+          .number()
+          .check(
+            z.int(),
+            z.nonnegative(),
+            z.describe('Event position within the parent-chain block.'),
+            z.meta({ examples: [4] }),
+          ),
+        status: z
+          .enum(['failed', 'completed'])
+          .check(
+            z.describe('Whether parent-chain delivery or processing failed or completed.'),
+            z.meta({ examples: ['failed', 'completed'] }),
+          ),
+        transactionHash: Schema.hash(exampleTransactionHash).check(
+          z.describe('Parent-chain transaction that processed the withdrawal.'),
+        ),
+        zoneStatus: z
+          .enum(['pending', 'completed'])
+          .check(
+            z.describe(
+              'Completed once the Zone has proven it imported the parent-chain `blockNumber` containing this withdrawal.',
+            ),
+            z.meta({ examples: ['pending', 'completed'] }),
+          ),
+      })
+      .check(z.describe('A Zone withdrawal processed on its parent chain.'))
+
+    /** Non-paginated list of indexed Zone withdrawal outcomes. */
+    export const Response = Schema.describe(
+      z.object({
+        data: z
+          .array(Withdrawal)
+          .check(
+            z.describe(
+              'Indexed parent-chain withdrawal outcomes sharing the sender tag. The list may grow while matching withdrawals are processed.',
+            ),
+          ),
+      }),
+      'A non-paginated list of parent-chain withdrawal outcomes correlated by sender tag.',
+    )
+  }
+}
+
+/** Creates Zone handlers. */
+export function zones() {
+  return new Hono<App.Environment>().get(
+    '/v1/zones/withdrawals/:senderTag',
+    Auth.policy({ apiKey: { scopes: ['data:read'] } }),
+    OpenApi.validate('param', schema.listZoneWithdrawals.Params, {
+      code: 'sender_tag_invalid',
+      message: 'Invalid sender tag',
+    }),
+    OpenApi.validate('query', schema.listZoneWithdrawals.Query, {
+      code: 'query_invalid',
+      message: 'Invalid query parameters',
+    }),
+    OpenApi.describeRoute({
+      description:
+        'Lists L1 withdrawal outcomes by Zone sender tag. L1 success requires every `status` completed; Zone success also requires every `zoneStatus` completed. Empty lists remain pending.',
+      operationId: 'listZoneWithdrawals',
+      responses: OpenApi.responses({
+        errors: {
+          400: {
+            codes: [
+              'api_key_malformed',
+              'chain_id_invalid',
+              'chain_id_unsupported',
+              'query_invalid',
+              'sender_tag_invalid',
+            ],
+          },
+          403: 'The API key does not grant read access to the originating Zone.',
+          502: 'The parent-chain indexer or RPC returned unavailable or malformed data.',
+        },
+        success: {
+          description: 'Indexed parent-chain withdrawal outcomes correlated by sender tag.',
+          examples: {
+            empty: {
+              summary: 'Not indexed',
+              value: { data: [] },
+            },
+            processed: {
+              summary: 'Processed',
+              value: {
+                data: [
+                  {
+                    blockNumber: 123,
+                    id: exampleWithdrawalId,
+                    logIndex: 4,
+                    status: 'completed',
+                    transactionHash: exampleTransactionHash,
+                    zoneStatus: 'pending',
+                  },
+                ],
+              },
+            },
+          },
+          schema: schema.listZoneWithdrawals.Response,
+        },
+      }),
+      summary: 'List Zone withdrawals',
+      tags: ['Zones'],
+    }),
+    Cache.response<App.Environment>({
+      cacheControl: Cache.policies.noStore,
+      name: 'tempo-api:zone-withdrawals:v1',
+      key: (c) => {
+        const principal = Auth.getPrincipal(c)
+        return `${principal?.type ?? 'unknown'}:${principal?.id ?? 'unknown'}:${Cache.urlKey(c, schema.listZoneWithdrawals.Query)}`
+      },
+    }),
+    async (c) => {
+      if (Auth.narrowAccess) return Auth.accessError(c)
+      if (OpenApi.narrowValidation)
+        return OpenApi.validationError(c, {
+          code: 'sender_tag_invalid',
+          message: 'Invalid sender tag',
+        })
+      if (OpenApi.narrowValidation)
+        return OpenApi.validationError(c, {
+          code: 'query_invalid',
+          message: 'Invalid query parameters',
+        })
+      if (OpenApi.narrowValidation)
+        return OpenApi.validationError(c, {
+          code: 'chain_id_invalid',
+          message: 'Invalid chain id',
+        })
+
+      const { senderTag } = c.req.valid('param')
+      const { chainId } = c.req.valid('query')
+      const zone = c.get('zones').get(chainId)
+      if (!zone) return Response.unsupportedChainId(c, chainId, c.get('zones').keys())
+
+      try {
+        const parentChainId = Schema.ChainId.parse(zone.sourceId)
+        const portalContract = zone.contracts?.['portal']
+        const portal = Schema.Address.parse(
+          portalContract && 'address' in portalContract
+            ? portalContract.address
+            : portalContract?.[parentChainId]?.address,
+        )
+        const tidx = c.get('getTidx')(parentChainId)
+        const result = await Timing.time(c, 'zone_withdrawal', () =>
+          tidx.fetch({
+            chainId: parentChainId,
+            engine: 'clickhouse',
+            // Dynamic raw-log query, constrained to schema-validated hex literals.
+            // FINAL collapses replayed physical rows before returning distinct events.
+            query: `
+              SELECT block_num, log_idx, tx_hash, address, selector, topic1, topic2, data
+              FROM logs FINAL
+              WHERE address = '${portal}'
+                AND selector = '${withdrawalProcessedSelector}'
+                AND topic2 = '${senderTag}'
+              ORDER BY block_num ASC, log_idx ASC
+            ` as string,
+          }),
+        )
+        if (result.rows.length === 0)
+          return c.json(Response.validated(schema.listZoneWithdrawals.Response, { data: [] }), 200)
+
+        // TODO: Use `zone_getZoneInfo` once Zone RPC versions stabilize.
+        const tempoBlockNumber = await Timing.time(c, 'zone_status', () =>
+          c
+            .get('getClient')(parentChainId)
+            .readContract({
+              abi: [lastSyncedTempoBlockNumberFunction],
+              address: portal,
+              functionName: 'lastSyncedTempoBlockNumber',
+            }),
+        )
+        const data = resolveWithdrawalProcessed({
+          portal,
+          rows: result.rows,
+          senderTag,
+          tempoBlockNumber,
+        })
+        return c.json(Response.validated(schema.listZoneWithdrawals.Response, data), 200)
+      } catch (cause) {
+        return Response.upstream(c, cause)
+      }
+    },
+  )
+}
+
+/**
+ * Resolves indexed `WithdrawalProcessed` rows into public withdrawal outcomes
+ * and rejects malformed upstream data.
+ */
+export function resolveWithdrawalProcessed(
+  options: resolveWithdrawalProcessed.Options,
+): z.output<typeof schema.listZoneWithdrawals.Response> {
+  const { portal, rows, senderTag, tempoBlockNumber } = options
+  return {
+    data: rows.map((row) => {
+      const address = Schema.Address.safeParse(row['address'])
+      const blockNumber = Value.toNumber(row['block_num'])
+      const data = Schema.Hex.safeParse(row['data'])
+      const logIndex = Value.toNumber(row['log_idx'])
+      const selector = Schema.Hash.safeParse(row['selector'])
+      const topic1 = Schema.Hash.safeParse(row['topic1'])
+      const topic2 = Schema.Hash.safeParse(row['topic2'])
+      const transactionHash = Schema.Hash.safeParse(row['tx_hash'])
+      if (
+        !address.success ||
+        address.data !== portal ||
+        blockNumber === undefined ||
+        !Number.isSafeInteger(blockNumber) ||
+        blockNumber < 0 ||
+        !data.success ||
+        logIndex === undefined ||
+        !Number.isSafeInteger(logIndex) ||
+        logIndex < 0 ||
+        !selector.success ||
+        selector.data !== withdrawalProcessedSelector ||
+        !topic1.success ||
+        !topic2.success ||
+        topic2.data !== senderTag ||
+        !transactionHash.success
+      )
+        throw new Error('Upstream returned a malformed WithdrawalProcessed event')
+
+      const decoded = (() => {
+        try {
+          return AbiEvent.decode(withdrawalProcessedEvent, {
+            data: data.data,
+            topics: [selector.data, topic1.data, topic2.data],
+          })
+        } catch {
+          return undefined
+        }
+      })()
+      if (
+        !decoded ||
+        !Schema.Address.safeParse(decoded.to).success ||
+        decoded.senderTag.toLowerCase() !== senderTag ||
+        !Schema.Address.safeParse(decoded.token).success ||
+        typeof decoded.amount !== 'bigint' ||
+        typeof decoded.callbackSuccess !== 'boolean'
+      )
+        throw new Error('Upstream returned a malformed WithdrawalProcessed event')
+
+      return {
+        blockNumber,
+        id: `${transactionHash.data}-${logIndex}`,
+        logIndex,
+        status: decoded.callbackSuccess ? 'completed' : 'failed',
+        transactionHash: transactionHash.data,
+        zoneStatus: tempoBlockNumber >= BigInt(blockNumber) ? 'completed' : 'pending',
+      }
+    }),
+  }
+}
+
+export declare namespace resolveWithdrawalProcessed {
+  /** Inputs for resolving indexed Zone withdrawal processing rows. */
+  type Options = {
+    /** Configured ZonePortal address on the parent Tempo chain. */
+    portal: z.output<typeof Schema.Address>
+    /** Matching raw TIDX log rows ordered by parent-chain position. */
+    rows: readonly Record<string, unknown>[]
+    /** Sender tag supplied by the caller. */
+    senderTag: Hex.Hex
+    /** Latest parent-chain block the originating Zone proved it imported. */
+    tempoBlockNumber: bigint
+  }
+}

package/src/apps/docs/reference.ts

@@ -113,7 +113,7 @@ function inlineOpenrpc<spec extends { paths: Record<string, unknown> }>(spec: sp
   const paths: Record<string, unknown> = {}
   for (const [pathname, item] of Object.entries(spec.paths)) {
     let next = item
-    if (isRecord(item))
+    if (item && typeof item === 'object' && !Array.isArray(item))
       for (const [method, op] of Object.entries(item))
         if (isRpcOperation(op)) next = { ...item, [method]: { ...op, 'x-openrpc': openrpcSpec } }
     paths[pathname] = next
@@ -124,9 +124,11 @@ function inlineOpenrpc<spec extends { paths: Record<string, unknown> }>(spec: sp
 // The JSON-RPC passthrough's operation id, set by its route definition and
 // targeted by `App.create`'s `applyOpenrpcLink`.
 function isRpcOperation(op: unknown): op is Record<string, unknown> {
-  return isRecord(op) && op['operationId'] === 'rpcRequest'
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value)
+  return (
+    !!op &&
+    typeof op === 'object' &&
+    !Array.isArray(op) &&
+    'operationId' in op &&
+    op.operationId === 'rpcRequest'
+  )
 }

package/src/apps/index.ts

@@ -1,5 +1,6 @@
-export { data, FundingQuoteProviders, FxOracle } from './data/index.js'
+export { data, FxOracle } from './data/index.js'
 export { management } from './management/index.js'
 export { mcp } from './mcp.js'
 export { mpp } from './mpp/index.js'
 export { relay } from './relay/index.js'
+export * as Zones from './Zones.js'

package/src/apps/management/Billing.test.ts

@@ -576,4 +576,33 @@ describe('createRequestUsageReporter', () => {
     expect((await RequestUsage.getBucket(db, { bucketStart, environment: 'production', orgId: 'org_1' }))?.reportedCount).toBe(6) // prettier-ignore
     await db.close()
   })
+
+  test('behavior: exposes the durable retry backlog for alerting', async () => {
+    const db = create()
+    await db.migrate()
+    await StripeCustomers.create(db, { orgId: 'org_1', stripeCustomerId: 'cus_1' })
+    await StripeCustomers.setStatus(db, 'org_1', 'active')
+    const { stripe } = stubStripe({
+      meterEvent() {
+        throw new Error('Stripe unavailable')
+      },
+      subscriptions: [{ items: ['feePayerSpend', 'apiRequests'], status: 'active' }],
+    })
+    const reporter = Billing.createRequestUsageReporter({
+      db,
+      now: () => Date.now(),
+      readCounts: async () => [{ bucketStart, count: 4, orgId: 'org_1' }],
+      stripe,
+    })
+
+    expect(await reporter.tick()).toStrictEqual({ failed: 1, reported: 0, skipped: 0 })
+    expect(await reporter.pending()).toEqual([
+      {
+        count: 1,
+        environment: 'production',
+        oldestPendingAgeSeconds: expect.any(Number),
+      },
+    ])
+    await db.close()
+  })
 })

package/src/apps/management/Billing.ts

@@ -444,6 +444,20 @@ export function createRequestUsageReporter(
     ...(sandboxStripe ? [{ client: sandboxStripe, environment: 'sandbox' as const }] : []),
   ]
   return {
+    async pending() {
+      return Promise.all(
+        clients.map(async ({ environment }) => {
+          const status = await RequestUsage.getPendingStatus(Db.get(db), environment)
+          return {
+            count: status.count,
+            environment,
+            oldestPendingAgeSeconds: status.oldestAttemptedAt
+              ? Math.max(0, Math.floor((now() - new Date(status.oldestAttemptedAt).getTime()) / 1_000))
+              : 0,
+          }
+        }),
+      )
+    },
     async tick() {
       const database = Db.get(db)
       let failed = 0
@@ -583,9 +597,18 @@ export declare namespace createRequestUsageReporter {
 
   /** A scheduled request-metering job. */
   type Reporter = {
+    /** Reads the current retry backlog without sending meter events. */
+    pending(): Promise<readonly Pending[]>
     /** Runs one reporting pass across production (and sandbox when configured). */
     tick(): Promise<{ failed: number; reported: number; skipped: number }>
   }
+
+  /** Current durable retry backlog for one billing environment. */
+  type Pending = {
+    count: number
+    environment: StripeCustomers.Record['environment']
+    oldestPendingAgeSeconds: number
+  }
 }
 
 /** Composite key for the in-tick blocked-bucket set. */

package/src/apps/management/Error.ts

@@ -0,0 +1,12 @@
+import type { Context } from 'hono'
+
+import * as Response from '../../internal/Response.js'
+
+/** Returns the standard error for operations that require a user session. */
+export function sessionRequired(c: Context) {
+  return Response.error(c, {
+    code: 'forbidden',
+    message: 'Session required',
+    status: 403,
+  })
+}

package/src/apps/management/routes/api-keys.test.ts

@@ -119,9 +119,11 @@ describe('keys', () => {
 
     // Even the org owner cannot self-mint zone access: membership is
     // controlled zone-side, so zone scopes are super-admin-issued.
-    const denied = await app.request(base, json('POST', owner, { scopes: ['zone:421700001:read'] }))
-    expect(denied.status).toBe(403)
-    expect(await denied.json()).toMatchObject({ error: { code: 'scope_not_issuable' } })
+    for (const scope of ['zone:421700001:read', 'zone:421700001:write']) {
+      const denied = await app.request(base, json('POST', owner, { scopes: [scope] }))
+      expect(denied.status).toBe(403)
+      expect(await denied.json()).toMatchObject({ error: { code: 'scope_not_issuable' } })
+    }
   })
 
   test('restricts project management keys without delegating issuance', async () => {

package/src/apps/management/routes/api-keys.ts

@@ -12,6 +12,7 @@ import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
 import * as Scope from '../../../Scope.js'
+import * as ManagementError from '../Error.js'
 
 /** Zod schemas owned by the API-keys resource. */
 export namespace schema {
@@ -281,7 +282,7 @@ export function apiKeys(options: apiKeys.Options = {}) {
         const kv = c.get('kv')
         if (!kv) return notEnabled(c)
         const createdBy = mintedBy(c)
-        if (!createdBy) return sessionRequired(c)
+        if (!createdBy) return ManagementError.sessionRequired(c)
 
         const body = c.req.valid('json')
 
@@ -582,11 +583,3 @@ function notEnabled(c: Context<App.Environment>) {
     status: 404,
   })
 }
-
-function sessionRequired(c: Context<App.Environment>) {
-  return Response.error(c, {
-    code: 'forbidden',
-    message: 'Session required',
-    status: 403,
-  })
-}

package/src/apps/management/routes/invitations.ts

@@ -8,6 +8,7 @@ import * as Memberships from '../../../db/tables/memberships.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
+import * as ManagementError from '../Error.js'
 
 import type { Email, Environment } from '../App.js'
 
@@ -386,7 +387,7 @@ export function invitations() {
         if (Auth.narrowAccess) return Auth.superAdminAccessError(c)
 
         const principal = Auth.getPrincipal(c)
-        if (principal?.type !== 'session') return sessionRequired(c)
+        if (principal?.type !== 'session') return ManagementError.sessionRequired(c)
         // Without a verified email there is nothing to match against.
         if (!principal.email)
           return c.json(Response.validated(schema.listMyInvitations.Response, { data: [] }), 200)
@@ -437,7 +438,7 @@ export function invitations() {
           })
 
         const principal = Auth.getPrincipal(c)
-        if (principal?.type !== 'session') return sessionRequired(c)
+        if (principal?.type !== 'session') return ManagementError.sessionRequired(c)
 
         const { invitationId } = c.req.valid('param')
         const db = Db.get(c.get('db'))
@@ -492,7 +493,7 @@ export function invitations() {
           })
 
         const principal = Auth.getPrincipal(c)
-        if (principal?.type !== 'session') return sessionRequired(c)
+        if (principal?.type !== 'session') return ManagementError.sessionRequired(c)
 
         const { invitationId } = c.req.valid('param')
         const db = Db.get(c.get('db'))
@@ -575,11 +576,3 @@ function invitationNotFound(c: Context<Environment>) {
     status: 404,
   })
 }
-
-function sessionRequired(c: Context<Environment>) {
-  return Response.error(c, {
-    code: 'forbidden',
-    message: 'Session required',
-    status: 403,
-  })
-}

package/src/apps/management/routes/orgs.ts

@@ -11,6 +11,7 @@ import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Organizations from '../../../db/tables/organizations.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
+import * as ManagementError from '../Error.js'
 
 /** Zod schemas owned by the organizations resource. */
 export namespace schema {
@@ -178,7 +179,7 @@ export function orgs() {
 
         const principal = Auth.getPrincipal(c)
         if (principal?.type !== 'session' && principal?.type !== 'super_admin')
-          return sessionRequired(c)
+          return ManagementError.sessionRequired(c)
 
         const body = c.req.valid('json')
         const db = Db.get(c.get('db'))
@@ -380,11 +381,3 @@ function organizationNotFound(c: Context<App.Environment>) {
     status: 404,
   })
 }
-
-function sessionRequired(c: Context<App.Environment>) {
-  return Response.error(c, {
-    code: 'forbidden',
-    message: 'Session required',
-    status: 403,
-  })
-}

package/src/apps/management/routes/scopes.test.ts

@@ -14,10 +14,14 @@ describe('scopes', () => {
     expect(response.headers.get('cache-control')).toMatchInlineSnapshot(
       `"private, max-age=300, stale-while-revalidate=3600"`,
     )
-    expect(body.data).toEqual([...Scope.catalog, Scope.zoneEntry].map((entry) => ({ ...entry })))
+    expect(body.data).toEqual(
+      [...Scope.catalog, Scope.zoneEntry, Scope.zoneWriteEntry].map((entry) => ({ ...entry })),
+    )
     expect(body.data.map((entry) => entry.scope)).toMatchInlineSnapshot(`
       [
         "data:read",
+        "funding:read",
+        "funding:write",
         "indexer:query",
         "management:read",
         "management:write",
@@ -27,6 +31,7 @@ describe('scopes', () => {
         "webhooks:read",
         "webhooks:write",
         "zone:<chainId>:read",
+        "zone:<chainId>:write",
       ]
     `)
   })
@@ -42,6 +47,6 @@ describe('scopes', () => {
     const body = await TestApp.json(response, Scopes.schema.getScopes.Response)
 
     expect(response.status).toBe(200)
-    expect(body.data).toEqual([...Scope.catalog, Scope.zoneEntry, custom])
+    expect(body.data).toEqual([...Scope.catalog, Scope.zoneEntry, Scope.zoneWriteEntry, custom])
   })
 })

package/src/apps/management/routes/scopes.ts

@@ -24,7 +24,7 @@ export namespace schema {
           .string()
           .check(
             z.describe(
-              'Scope identifier used in API-key grants and route policies. `zone:<chainId>:read` is a template: grants carry a concrete zone chain id.',
+              'Scope identifier used in API-key grants and route policies. Zone templates carry a concrete chain id and access level in grants.',
             ),
             z.meta({ examples: ['data:read'] }),
           ),
@@ -66,7 +66,7 @@ export function scopes() {
     }),
     Cache.response<App.Environment>({
       cacheControl: Cache.policies.stable,
-      name: 'tempo-api:scopes:v3',
+      name: 'tempo-api:scopes:v5',
       key: (c) => {
         const url = new URL(c.req.url)
         url.search = ''

package/src/apps/management/routes/webhooks.test.ts

@@ -2,6 +2,7 @@ import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 
 import * as App from '../../../App.js'
 import * as Memberships from '../../../db/tables/memberships.js'
+import * as Cursor from '../../../internal/Cursor.js'
 import * as core_Webhooks from '../../../internal/Webhooks.js'
 import * as TestApp from '../../../../test/App.js'
 import { management } from '../App.js'
@@ -47,7 +48,8 @@ async function organization(app: ReturnType<typeof createApp>, cookie: string) {
 
 describe('webhooks', () => {
   test('creates, lists, pauses, and deletes an organization webhook', async () => {
-    const app = createApp()
+    const db = TestApp.database()
+    const app = createApp({ db })
     const cookie = await session(app)
     const org = await organization(app, cookie)
     const collection = `/v1/orgs/${org.id}/webhooks`
@@ -65,6 +67,9 @@ describe('webhooks', () => {
     expect(createdResponse.status).toBe(200)
     const created = await TestApp.json(createdResponse, Webhooks.schema.createWebhook.Response)
     expect(created).toHaveProperty('secret', expect.stringMatching(/^whsec_/))
+    expect(Cursor.decode((await core_Webhooks.getCursor(db, created.id))!, ['int'])).toEqual([
+      expect.any(Number),
+    ])
 
     const listedResponse = await app.request(collection, { headers: { cookie } })
     expect(listedResponse.status).toBe(200)