tapimo 0.10.2 → 0.11.0

package/src/Webhooks.ts

@@ -1,18 +1,6 @@
-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 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
-// `createPoller` below.
+// `Webhooks` namespace.
 export * from './internal/Webhooks.js'
 
 // Re-export the webhook resource's zod schemas so consumers can validate and
@@ -20,210 +8,3 @@ export * from './internal/Webhooks.js'
 // `type`), plus the per-event `TransferEvent` / `TransactionEvent` / `PingEvent`
 // payloads. Infer a type with `z.infer<typeof Webhooks.schema.Envelope>`.
 export { enrichEventData, eventTypes, scanBlock, schema } from './apps/data/routes/webhooks.js'
-
-/**
- * Builds a webhook poller bound to a state store and chain config.
- *
- * 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.
- *
- * 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 = 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
-
-  return {
-    async tick(input = {}) {
-      const chainId = input.chainId ?? options.defaultChainId ?? Viem.defaultChainId
-
-      // Wrap the transport so each enqueue (or inline delivery) emits a timed
-      // `webhook:enqueue` metric. The wrapper preserves the dispatch contract: it
-      // 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) => {
-              const start = Date.now()
-              const result = await inner(dispatchable)
-              metrics.record({
-                chainId: dispatchable.envelope.chainId,
-                durationMs: Date.now() - start,
-                eventType: dispatchable.envelope.type,
-                ok: result.ok,
-                type: 'webhook:enqueue',
-              })
-              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,
-          cache,
-          chainId,
-          client: getClient(chainId),
-          confirmations: input.confirmations ?? options.confirmations,
-          db,
-          dispatch,
-          dispatchBatch,
-          eventTypes: input.eventTypes ?? options.eventTypes,
-          ...(input.headBlockNumber === undefined
-            ? {}
-            : { headBlockNumber: input.headBlockNumber }),
-          maxBlocks: input.maxBlocks ?? options.maxBlocks,
-          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',
-        })
-        return result
-      } catch (error) {
-        metrics?.record({
-          cursorLagBlocks,
-          meta: { chainId, durationMs: Date.now() - start, outcome: 'error' },
-          result: undefined,
-          type: 'webhook:tick',
-        })
-        throw error
-      } finally {
-        metrics?.flush()
-      }
-    },
-  }
-}
-
-export declare namespace createPoller {
-  /** A row to dispatch, paired with its owning subscription. */
-  type Dispatchable = AppWebhooks.poll.Dispatchable
-
-  /** 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
-
-  /** Knobs shared by every {@link Poller.tick}; each is overridable per tick. */
-  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 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). */
-    maxBlocks?: number | undefined
-    /** Clock for envelope timestamps; injectable for tests. */
-    now?: (() => Date) | undefined
-  }
-
-  /** 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 that scan chain events. */
-    rpc?: Viem.getClient.Rpc | undefined
-  }
-
-  /** Per-tick overrides; falls back to the {@link Options} defaults. */
-  type TickOptions = Defaults & {
-    /** Chain to poll this tick (default `options.defaultChainId`). */
-    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 chain-head-driven webhook poller. */
-  type Poller = {
-    /** Runs one poll tick, resolving the RPC head when not supplied. */
-    tick(options?: TickOptions): Promise<Result>
-  }
-}

package/src/apps/data/App.ts

@@ -224,7 +224,13 @@ export function data(options: data.Options = {}) {
     .route('/', transactionActivities({ fx: options.fx }))
     .route('/', transfers({ fx: options.fx }))
     .route('/', verifiedTokens())
-    .route('/', webhooks({ enabled: options.webhook !== false }))
+    .route(
+      '/',
+      webhooks({
+        applicationEventTypes: webhook?.applicationEventTypes ?? [],
+        enabled: options.webhook !== false,
+      }),
+    )
     .route('/', zones())
     .route('/', rpc())
     .route('/', coingecko())
@@ -445,7 +451,7 @@ function webhooksBlock() {
             'tempo-event-id',
             'A unique, stable id for this event (`evt_…`). The same event may be delivered more than once, so use this id to skip duplicates.',
           ),
-          header('tempo-event-type', 'What happened: `token:transfer`, `transaction:included`, `log:emitted`, `block:created`, or `ping`.'), // prettier-ignore
+          header('tempo-event-type', 'What happened: `token:transfer`, `transaction:included`, `log:emitted`, `block:created`, `funding:deposit.updated`, or `ping`.'), // prettier-ignore
         ],
         requestBody: {
           content: { 'application/json': { schema: envelope } },

package/src/apps/data/routes/activities.test.ts

@@ -35,8 +35,6 @@ const liveAccounts = {
   channel: '0x5217c502adf3c96a9551770af4caa5f5144a6984',
   // TokenCreated + Mint + Transfer.
   creator: '0x253fb3bf1e3d75ad6ee1554f68f4ea0568f7d24e',
-  // Token burns.
-  burner: '0x69519497b59bd64e109d993157d45f14455cc7e6',
   // KeyAuthorized + KeyRevoked + Approval (+ transfer/mint/exchange).
   keychain: '0xfe776fd28e06ecc71a157398b2c9991318f1ea2e',
   // Swaps through the stablecoin DEX (output kept, so it stays a plain `swap`).
@@ -50,27 +48,29 @@ const accounts =
     ? {
         channel: localAccounts.keychain,
         creator: localAccounts.creator,
-        burner: localAccounts.burner,
         keychain: localAccounts.keychain,
         swapper: localAccounts.swapper,
       }
     : liveAccounts
 
-/** The account expected to surface each activity type. */
+/**
+ * The account expected to surface each activity type. Burns are seeded per run
+ * instead: a live burner keeps accruing activity until its last burn falls off
+ * the first page.
+ */
 const coverage =
-  runtime.mode === 'localnet'
+  runtime.mode === 'localnet' && localAccounts
     ? {
-        approval: accounts.keychain,
-        burn: accounts.burner,
-        mint: accounts.creator,
-        'token-created': accounts.creator,
-        transfer: accounts.creator,
+        approval: localAccounts.keychain,
+        burn: localAccounts.burner,
+        mint: localAccounts.creator,
+        'token-created': localAccounts.creator,
+        transfer: localAccounts.creator,
       }
     : {
         'access-key-created': accounts.keychain,
         'access-key-revoked': accounts.keychain,
         approval: accounts.keychain,
-        burn: accounts.burner,
         mint: accounts.creator,
         'session-closed': accounts.channel,
         swap: accounts.swapper,
@@ -165,6 +165,54 @@ describe('GET /addresses/:address/activities', () => {
     expect(find(body.data, type)).toBeDefined()
   })
 
+  // Localnet seeds its burner through the shared fixtures, so this covers the
+  // hosted testnet, where no address stays burn-topped for long.
+  test.skipIf(runtime.mode === 'localnet')(
+    'classifies a seeded burn',
+    async () => {
+      const account = Tempo.accounts[11]
+      const wallet = Tempo.getClient({ account })
+      await Actions.faucet.fundSync(Tempo.client, { account, timeout: 60_000 })
+
+      // Burning needs the `issuer` role, so the account burns a token it owns.
+      const { token } = await Actions.token.createSync(wallet, {
+        currency: 'USD',
+        name: 'Seeded Burn USD',
+        symbol: 'SBUSD',
+      })
+      await sendTransactionSync(wallet, {
+        account,
+        calls: [
+          Actions.token.grantRoles.call(wallet, { role: 'issuer', to: account.address, token }),
+          Actions.token.mint.call(wallet, { amount: 1_000_000n, to: account.address, token }),
+        ],
+      })
+      const { receipt } = await Actions.token.burnSync(wallet, { amount: 100_000n, token })
+
+      const deadline = Date.now() + 90_000
+      let burn: Activities.Entry | undefined
+      while (Date.now() < deadline) {
+        const response = await client.v1.addresses[':address'].activities.$get(
+          { param: { address: account.address }, query: { limit: '50' } },
+          { headers: { 'cache-control': 'no-store', ...TestApp.auth.headers } },
+        )
+        if (response.status === 200) {
+          const body = await TestApp.json(response, Activities.schema.getAddressActivities.Response)
+          burn = find(body.data, 'burn')
+          if (burn?.type === 'burn' && burn.transactionHash === receipt.transactionHash) break
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500))
+      }
+      expect(burn?.type).toBe('burn')
+      if (burn?.type !== 'burn') return
+      expect(burn.transactionHash).toBe(receipt.transactionHash)
+      expect(burn.data.sender.toLowerCase()).toBe(account.address.toLowerCase())
+      expect(burn.data.sourceToken.address.toLowerCase()).toBe(token.toLowerCase())
+      expect(burn.data.sourceAmount.baseUnits).toBe('100000')
+    },
+    180_000,
+  )
+
   test('transfer data mirrors the `Transfer` resource', async () => {
     const transfer = find((await activities(accounts.creator)).data, 'transfer')
     expect(transfer?.type).toBe('transfer')
@@ -666,6 +714,54 @@ describe('Activities.list classification', () => {
     expect(log.data).toBe('0x1234')
     expect(log.topics).toEqual([unknownSelector, pad(viewer)])
   })
+
+  test('degrades a topic-encoded approval with a fee transfer to `unknown`', async () => {
+    const approvalToken = '0x4120c7ec7e9ead9dcf44b35b5134ebdbfc6e3de9' as Address.Address
+    const feeToken = '0x20c0000000000000000000000000000000000000' as Address.Address
+    const feeManager = '0xfeec000000000000000000000000000000000000'
+    const approvalSelector = '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925'
+    const transferSelector = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'
+    const pad = (value: string) => `0x${value.slice(2).padStart(64, '0')}`
+    const txHash = '0xd2439ad8016d4ffd6aebe835734ee4d118a688714a4f9aebcc11f87a2b22e896' as Hex.Hex
+    const common = {
+      blockNum: 15_781_805,
+      blockTimestamp: 1_776_703_284,
+      feePayer: viewer,
+      source: 'q1' as const,
+      txHash,
+      txIdx: 0,
+      txSender: viewer,
+    }
+    const { items } = await Activities.list(
+      provider([
+        {
+          ...common,
+          data: '0x',
+          logAddress: approvalToken,
+          logIdx: 0,
+          selector: approvalSelector,
+          topic1: pad(viewer),
+          topic2: pad('0x6063259f720ee125e5bff693779ab8118b0118a7'),
+          topic3: '0x2a9063ed52b7d417e441f378325359c9ce274f5d6c3ecf11b7d42f24b9c90b7f',
+        },
+        {
+          ...common,
+          data: `0x${(5_815).toString(16).padStart(64, '0')}`,
+          logAddress: feeToken,
+          logIdx: 1,
+          selector: transferSelector,
+          topic1: pad(viewer),
+          topic2: pad(feeManager),
+          topic3: null,
+        },
+      ]),
+      { address: viewer, store: store() },
+    )
+
+    expect(items).toHaveLength(1)
+    expect(items[0]?.type).toBe('unknown')
+    expect(items[0]?.events).toHaveLength(2)
+  })
 })
 
 describe('Activities.list precompile classification', () => {

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

@@ -2727,15 +2727,46 @@ function classifyFromLogs(
     viewer: Address.Address
   },
 ): RawItem[] {
-  const items = classifyFromLogsCore(rows, ctx)
+  const decoded = decodeRows(rows)
+  const items = (() => {
+    try {
+      return classifyFromLogsCore(rows, ctx, decoded)
+    } catch {
+      // Indexed logs can match a known signature without satisfying that event's expected shape.
+      return [
+        unknown(ctx.itemBase(Math.min(...rows.map((row) => row.logIdx))), {
+          events: buildTxEvents(rows, decoded),
+          signer: signerForRows(rows, { fallback: ctx.signer, viewer: ctx.viewer }),
+        }),
+      ]
+    }
+  })()
   // When the caller requested raw logs, attach the full per-transaction log set
   // (decoded when possible) to every classified item so no co-located log is
   // hidden behind the headline. `unknown` items already carry it.
   if (!ctx.includeLogs) return items
-  const events = buildTxEvents(rows, decodeRows(rows))
+  const events = buildTxEvents(rows, decoded)
   return items.map((item) => (item.type === 'unknown' ? item : { ...item, events }))
 }
 
+/** Resolves an access-key signer from raw rows, falling back to the transaction signer. */
+function signerForRows(
+  rows: readonly Row[],
+  options: { fallback: 'self' | Address.Address; viewer: Address.Address },
+) {
+  const accessKeySpendRow = rows.find(
+    (row) =>
+      row.selector === accessKeySpendSelector &&
+      Address.isEqual(row.logAddress, Addresses.accountKeychain),
+  )
+  const accessKeySigner = accessKeySpendRow?.topic2
+    ? (`0x${accessKeySpendRow.topic2.slice(-40)}`.toLowerCase() as Address.Address)
+    : null
+  return accessKeySigner && !Address.isEqual(accessKeySigner, options.viewer)
+    ? accessKeySigner
+    : options.fallback
+}
+
 /** Classifies a Q1 (log-bearing) group via `parseEventLogs`, picking one headline item. */
 function classifyFromLogsCore(
   rows: Row[],
@@ -2746,24 +2777,11 @@ function classifyFromLogsCore(
     signer: 'self' | Address.Address
     viewer: Address.Address
   },
+  events = decodeRows(rows),
 ): RawItem[] {
   const { blockNum, fingerprintMap, itemBase, viewer } = ctx
 
-  // An access-key-signed tx emits AccessKeySpend at the accountKeychain; topic2
-  // is the access-key publicKey. Use it as the signer so successive access-key
-  // actions group together.
-  const accessKeySpendRow = rows.find(
-    (r) =>
-      r.selector === accessKeySpendSelector &&
-      Address.isEqual(r.logAddress, Addresses.accountKeychain),
-  )
-  const accessKeySigner = accessKeySpendRow?.topic2
-    ? (`0x${accessKeySpendRow.topic2.slice(-40)}`.toLowerCase() as Address.Address)
-    : null
-  const signer: 'self' | Address.Address =
-    accessKeySigner && !Address.isEqual(accessKeySigner, viewer) ? accessKeySigner : ctx.signer
-
-  const events = decodeRows(rows)
+  const signer = signerForRows(rows, { fallback: ctx.signer, viewer })
 
   const minLogIndex = Math.min(...rows.map((r) => r.logIdx))
 
@@ -3251,6 +3269,14 @@ function classifyFromLogsCore(
   const approvalEvent = finalEvents.find(
     (e) =>
       e.eventName === 'Approval' &&
+      // ERC-721 uses the same selector but indexes its token ID as topic3. In
+      // non-strict mode viem otherwise decodes the missing ERC-20 amount as zero.
+      rows.some(
+        (row) =>
+          row.logIdx === e.logIndex &&
+          row.topic3 === null &&
+          /^0x[0-9a-fA-F]{64}$/.test(row.data ?? ''),
+      ) &&
       !Address.isEqual((e.args as { spender: Address.Address }).spender, Addresses.zoneOutbox),
   )
   if (approvalEvent) {
@@ -4338,21 +4364,27 @@ function unknown(
 
 /** Decodes a group's raw rows into `viem/tempo` events via `parseEventLogs` (non-strict). */
 function decodeRows(rows: readonly Row[]) {
-  const viemLogs: Log[] = rows.map((r) => ({
-    address: r.logAddress as `0x${string}`,
-    blockHash: '0x0' as Hex.Hex,
-    blockNumber: BigInt(r.blockNum),
-    data: (r.data ?? '0x') as Hex.Hex,
-    logIndex: r.logIdx,
-    removed: false,
-    topics: [r.selector, r.topic1, r.topic2, r.topic3].filter(Boolean) as [Hex.Hex, ...Hex.Hex[]],
-    transactionHash: r.txHash as `0x${string}`,
-    transactionIndex: r.txIdx,
-  }))
-  return parseEventLogs({
-    abi: [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault],
-    logs: viemLogs,
-    strict: false,
+  return rows.flatMap((r) => {
+    const log: Log = {
+      address: r.logAddress as `0x${string}`,
+      blockHash: '0x0' as Hex.Hex,
+      blockNumber: BigInt(r.blockNum),
+      data: (r.data ?? '0x') as Hex.Hex,
+      logIndex: r.logIdx,
+      removed: false,
+      topics: [r.selector, r.topic1, r.topic2, r.topic3].filter(Boolean) as [Hex.Hex, ...Hex.Hex[]],
+      transactionHash: r.txHash as `0x${string}`,
+      transactionIndex: r.txIdx,
+    }
+    try {
+      return parseEventLogs({
+        abi: [...Abis.abis, ...Abis.earnRouter, ...Abis.earnVault],
+        logs: [log],
+        strict: false,
+      })
+    } catch {
+      return []
+    }
   })
 }