tapimo 0.10.2 → 0.12.0

package/dist/apps/data/routes/webhooks.js

@@ -1,9 +1,9 @@
 import { Hono } from 'hono';
 import { decodeEventLog, encodeEventTopics, parseAbiItem } from 'viem';
 import * as z from 'zod/mini';
+import * as Scope from '../../../Scope.js';
 import * as Auth from '../../../internal/Auth.js';
 import * as Cache from '../../../internal/Cache.js';
-import * as Cursor from '../../../internal/Cursor.js';
 import * as Db from '../../../db/Db.js';
 import * as OpenApi from '../../../internal/OpenApi.js';
 import * as Response from '../../../internal/Response.js';
@@ -14,6 +14,7 @@ import * as Value from '../../../internal/Value.js';
 import * as WebhookDestination from '../../../internal/WebhookDestination.js';
 import * as WebhookTransfer from '../../../internal/WebhookTransfer.js';
 import * as Webhooks from '../../../internal/Webhooks.js';
+import * as FundingDeposit from '../../../internal/funding/Deposit.js';
 import * as Transactions from './transactions.js';
 import * as Transfers from './transfers.js';
 /** Default cap on live subscriptions per owner, overridable via `webhook.maxPerOwner`. */
@@ -33,6 +34,7 @@ const redactedSlackUrl = 'https://hooks.slack.com/…';
  */
 export const eventTypes = [
     'block:created',
+    'funding:deposit.updated',
     'log:emitted',
     'token:transfer',
     'transaction:included',
@@ -43,6 +45,10 @@ const eventTypeDescriptions = [
         description: 'A new block was added to the chain. Filter by producer, gas usage, or block number, or omit filters for a per-block heartbeat.',
         type: 'block:created',
     },
+    {
+        description: 'A funding deposit materially changed after verified reconciliation, filterable by deposit address, recipient, or status.',
+        type: 'funding:deposit.updated',
+    },
     {
         description: 'Any contract event log, filtered by emitting address, event signature/topics, or decoded arguments.',
         type: 'log:emitted',
@@ -268,6 +274,14 @@ export var schema;
         timestamp: z.optional(schema.compare.check(z.describe('Only match blocks whose unix timestamp (seconds) is within these bounds.'))),
     })
         .check(z.describe('Filters that narrow which new blocks trigger this webhook.'), z.meta({ title: 'Block filters' }));
+    /** `funding:deposit.updated` subscription filters. All are optional and AND-combined. */
+    schema.FundingDepositFilters = z
+        .strictObject({
+        depositAddressId: z.optional(FundingDeposit.schema.Snapshot.shape.depositAddressId),
+        recipient: z.optional(Schema.Address),
+        status: z.optional(FundingDeposit.schema.Status),
+    })
+        .check(z.describe('Filters that narrow which funding deposit changes trigger this webhook.'), z.meta({ title: 'Funding deposit filters' }));
     /**
      * Optional human context describing what a subscription is for. Surfaced by
      * destinations (Slack header + description, Better Stack log fields) and echoed
@@ -300,20 +314,23 @@ export var schema;
             .datetime()
             .check(z.describe('When the subscription was created, as an ISO 8601 timestamp.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })),
         destination: PublicDestination,
+        environment: z
+            .optional(z.enum(['production', 'sandbox']))
+            .check(z.describe('API-key environment for private resource events, when applicable.'), z.meta({ examples: ['production'] })),
         eventType: schema.EventType.check(z.meta({ examples: ['token:transfer'] })),
         expiresAt: z
             .optional(z.iso.datetime())
             .check(z.describe('When the subscription expires, as an ISO 8601 timestamp. Only MPP-paid subscriptions expire.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })),
         failureCount: z
             .number()
-            .check(z.int(), z.nonnegative(), z.describe('Number of delivery failures in a row for this subscription.'), z.meta({ examples: [0] })),
+            .check(z.int(), z.nonnegative(), z.describe('Number of delivery failures in a row for this subscription, capped at the auto-disable threshold.'), z.meta({ examples: [0] })),
         filters: Filters.check(z.describe('Filters applied to this event type.'), z.meta({ examples: [{ address: '0x20c0000000000000000000008f5425160ebe5525' }] })),
         id: z
             .string()
             .check(z.describe('Webhook subscription ID (`wh_…`).'), z.meta({ examples: ['wh_001718668800000_2ZPE2gvateYEQ0dQslgvkhjx'] })),
         lastDeliveryAt: z
             .optional(z.iso.datetime())
-            .check(z.describe('When Tempo last delivered an event successfully, as an ISO 8601 timestamp.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })),
+            .check(z.describe('When Tempo last delivered an event successfully, as an ISO 8601 timestamp. Refreshed at most once per minute during sustained delivery.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })),
         status: schema.Status.check(z.meta({ examples: ['active'] })),
         updatedAt: z.iso
             .datetime()
@@ -386,7 +403,7 @@ export var schema;
                 .string()
                 .check(z.describe('Token symbol (e.g. `USDC`).'), z.meta({ examples: ['USDC'] })),
         })
-            .check(z.describe('Best-effort token metadata (symbol/decimals) resolved by the poller so `amount` can render as a human amount. Omitted when the lookup is unavailable.'))),
+            .check(z.describe('Best-effort token metadata (symbol/decimals) resolved before delivery so `amount` can render as a human amount. Omitted when the lookup is unavailable.'))),
         transactionHash: Schema.Hash.check(z.describe('Transaction hash that contains this transfer.'), z.meta({
             examples: ['0x3d24a706cc2f6f4c96620bef1f61ddb23040ff77c22c8db42918c7c424bbf9d3'],
         })),
@@ -489,6 +506,8 @@ export var schema;
             .check(z.describe('When the block was produced, as an ISO 8601 timestamp.'), z.meta({ examples: ['2026-01-14T18:38:03.685Z'] })),
     })
         .check(z.describe('Payload for a `block:created` event (a new block header).'));
+    /** Public funding deposit after a committed material change. */
+    schema.FundingDepositEvent = FundingDeposit.schema.FundingDeposit;
     /** A `ping` (synthetic test-delivery) payload, sent by `POST /webhooks/:id/ping`. */
     schema.PingEvent = z
         .object({
@@ -536,6 +555,13 @@ export var schema;
         z
             .object({ ...envelopeBase, data: schema.BlockEvent, type: z.literal('block:created') })
             .check(z.meta({ title: 'Block event' })),
+        z
+            .object({
+            ...envelopeBase,
+            data: schema.FundingDepositEvent,
+            type: z.literal('funding:deposit.updated'),
+        })
+            .check(z.meta({ title: 'Funding deposit updated event' })),
         z
             .object({ ...envelopeBase, data: schema.PingEvent, type: z.literal('ping') })
             .check(z.meta({ title: 'Ping (test delivery)' })),
@@ -612,6 +638,17 @@ export var schema;
                 filters: z.optional(schema.BlockFilters),
             })
                 .check(z.meta({ title: 'Block subscription' })),
+            z
+                .object({
+                chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
+                context: z.optional(schema.Context),
+                destination: Destination,
+                eventType: z
+                    .literal('funding:deposit.updated')
+                    .check(z.describe('Event type for committed funding deposit changes.'), z.meta({ examples: ['funding:deposit.updated'] })),
+                filters: z.optional(schema.FundingDepositFilters),
+            })
+                .check(z.meta({ title: 'Funding deposit subscription' })),
         ])
             .check(z.describe('Details for creating a webhook subscription.'));
         createWebhook.Response = z
@@ -762,6 +799,9 @@ export var schema;
  */
 export function webhooks(options = {}) {
     const hidden = !options.enabled;
+    const availableEventTypes = eventTypeDescriptions.filter((eventType) => eventType.type !== 'funding:deposit.updated' ||
+        options.applicationEventTypes?.includes(eventType.type));
+    const availableEventTypeSet = new Set(availableEventTypes.map((eventType) => eventType.type));
     // Gate the whole resource on a configured state store. Without it the
     // outbound-HTTP surface is disabled (read-only deployment).
     const gate = async (c, next) => {
@@ -804,7 +844,7 @@ export function webhooks(options = {}) {
         if (!c.get('webhook'))
             return notEnabled(c);
         return c.json(Response.validated(schema.getWebhookEventTypes.Response, {
-            data: eventTypeDescriptions.map((eventType) => ({ ...eventType })),
+            data: availableEventTypes.map((eventType) => ({ ...eventType })),
         }), 200);
     })
         .post('/v1/webhooks', Auth.policy({ apiKey: { scopes: ['webhooks:write'] } }), OpenApi.validate('json', schema.createWebhook.Body, {
@@ -817,12 +857,18 @@ export function webhooks(options = {}) {
         responses: OpenApi.responses({
             errors: {
                 400: {
-                    codes: ['body_invalid', 'chain_id_unsupported', 'filters_invalid', 'url_invalid'],
+                    codes: [
+                        'body_invalid',
+                        'chain_id_unsupported',
+                        'event_type_unsupported',
+                        'filters_invalid',
+                        'url_invalid',
+                    ],
                     description: 'The request, destination, filters, or chain are invalid.',
                 },
                 403: {
-                    codes: ['limit_exceeded'],
-                    description: 'You have reached the webhook subscription limit.',
+                    codes: ['api_key_forbidden', 'limit_exceeded'],
+                    description: 'The API key lacks access or the subscription limit was reached.',
                 },
             },
             success: {
@@ -844,10 +890,27 @@ export function webhooks(options = {}) {
             });
         const webhook = c.get('webhook');
         const db = Db.get(c.get('db'));
+        const principal = Auth.getPrincipal(c);
         const owner = ownerFor(c);
         if (!owner)
             return unauthorized(c);
         const body = c.req.valid('json');
+        if (!availableEventTypeSet.has(body.eventType))
+            return Response.error(c, {
+                code: 'event_type_unsupported',
+                message: 'Webhook event type is not available in this deployment',
+                status: 400,
+            });
+        if (body.eventType === 'funding:deposit.updated') {
+            if (principal?.type !== 'api_key')
+                return unauthorized(c);
+            if (!principal.apiKey.scopes.some((scope) => scope === Scope.wildcard || scope === 'funding:read'))
+                return Response.error(c, {
+                    code: 'api_key_forbidden',
+                    message: 'API key missing required scope',
+                    status: 403,
+                });
+        }
         const chainId = body.chainId ?? c.get('chainId');
         const supportedChainIds = new Set(webhook.supportedChainIds);
         if (!supportedChainIds.has(chainId))
@@ -858,18 +921,28 @@ export function webhooks(options = {}) {
             const maxPerOwner = webhook.maxPerOwner ?? defaultMaxPerOwner;
             if ((await Webhooks.countSubscriptions(db, owner)) >= maxPerOwner)
                 throw new Webhooks.LimitExceededError(maxPerOwner);
-            const startBlockNumber = await getRpcHead(c.get('getClient')(chainId));
+            const startBlockNumber = body.eventType === 'funding:deposit.updated'
+                ? undefined
+                : await getRpcHead(c.get('getClient')(chainId));
             const subscription = await Webhooks.createSubscription(db, {
                 chainId,
                 ...(body.context === undefined ? {} : { context: body.context }),
                 destination: body.destination,
+                ...(principal?.type === 'api_key'
+                    ? {
+                        environment: principal.environment,
+                        ...(principal.projectId === undefined
+                            ? {}
+                            : { projectId: principal.projectId }),
+                    }
+                    : {}),
                 eventType: body.eventType,
                 filters: body.filters,
                 owner,
                 ...(owner.type === 'mpp' ? { ttl: mppTtlMs } : {}),
             }, {
                 maxPerOwner,
-                startBlockNumber,
+                ...(startBlockNumber === undefined ? {} : { startBlockNumber }),
             });
             return c.json(Response.validated(schema.createWebhook.Response, toCreated(subscription)), 200);
         }
@@ -906,17 +979,19 @@ export function webhooks(options = {}) {
         const owner = ownerFor(c);
         if (!owner)
             return unauthorized(c);
+        const access = accessFor(c);
         const { cursor, include, limit, page } = c.req.valid('query');
         try {
             // `totalCount` is opt-in and exact (the per-owner set is bounded);
             // run it concurrently with the page list. Best-effort: a failure
             // omits `meta` rather than failing the page.
             const countPromise = include.includes('totalCount')
-                ? Webhooks.countSubscriptions(db, owner).catch(() => undefined)
+                ? Webhooks.countSubscriptions(db, owner, { access }).catch(() => undefined)
                 : undefined;
             // Fetch one extra to detect a further page without a second round-trip.
             // `page` translates to a positional slice of `(page - 1) * limit` rows.
             const rows = await Webhooks.listSubscriptions(db, owner, {
+                access,
                 cursor,
                 limit: limit + 1,
                 offset: page !== undefined && page > 1 ? (page - 1) * limit : undefined,
@@ -976,9 +1051,10 @@ export function webhooks(options = {}) {
         const owner = ownerFor(c);
         if (!owner)
             return unauthorized(c);
+        const access = accessFor(c);
         const { id } = c.req.valid('param');
         try {
-            const subscription = await Webhooks.getSubscription(db, owner, id);
+            const subscription = await Webhooks.getSubscription(db, owner, id, { access });
             if (!subscription)
                 return notFound(c);
             return c.json(Response.validated(schema.getWebhook.Response, toPublic(subscription)), 200);
@@ -1030,12 +1106,13 @@ export function webhooks(options = {}) {
         const owner = ownerFor(c);
         if (!owner)
             return unauthorized(c);
+        const access = accessFor(c);
         const { id } = c.req.valid('param');
         const { cursor, include, limit, page } = c.req.valid('query');
         try {
             // Owner-scope first: resolving the subscription under the caller's owner
             // key 404s ids they don't own (indistinguishable from "doesn't exist").
-            const subscription = await Webhooks.getSubscription(db, owner, id);
+            const subscription = await Webhooks.getSubscription(db, owner, id, { access });
             if (!subscription)
                 return notFound(c);
             // `totalCount` is opt-in and exact (the delivery log is TTL-bounded);
@@ -1102,10 +1179,11 @@ export function webhooks(options = {}) {
         const owner = ownerFor(c);
         if (!owner)
             return unauthorized(c);
+        const access = accessFor(c);
         const { id } = c.req.valid('param');
         try {
             // Owner-scope first so unowned/unknown ids are indistinguishable (404).
-            const subscription = await Webhooks.getSubscription(db, owner, id);
+            const subscription = await Webhooks.getSubscription(db, owner, id, { access });
             if (!subscription)
                 return notFound(c);
             // Inline delivery (not the queue) so the caller gets an immediate
@@ -1159,10 +1237,11 @@ export function webhooks(options = {}) {
         const owner = ownerFor(c);
         if (!owner)
             return unauthorized(c);
+        const access = accessFor(c);
         const { deliveryId, id } = c.req.valid('param');
         try {
             // Owner-scope the subscription first so unowned ids 404 like elsewhere.
-            const subscription = await Webhooks.getSubscription(db, owner, id);
+            const subscription = await Webhooks.getSubscription(db, owner, id, { access });
             if (!subscription)
                 return notFound(c);
             const delivery = await Webhooks.getDelivery(db, id, deliveryId);
@@ -1240,6 +1319,7 @@ export function webhooks(options = {}) {
         const owner = ownerFor(c);
         if (!owner)
             return unauthorized(c);
+        const access = accessFor(c);
         const { id } = c.req.valid('param');
         const patch = c.req.valid('json');
         try {
@@ -1249,12 +1329,12 @@ export function webhooks(options = {}) {
             // persisting — otherwise a bad filter would silently widen the match
             // set at scan time.
             if (patch.filters !== undefined) {
-                const existing = await Webhooks.getSubscription(db, owner, id);
+                const existing = await Webhooks.getSubscription(db, owner, id, { access });
                 if (!existing)
                     return notFound(c);
                 parseFilters(existing.eventType, patch.filters);
             }
-            const subscription = await Webhooks.updateSubscription(db, owner, id, patch);
+            const subscription = await Webhooks.updateSubscription(db, owner, id, patch, { access });
             if (!subscription)
                 return notFound(c);
             return c.json(Response.validated(schema.updateWebhook.Response, toPublic(subscription)), 200);
@@ -1298,9 +1378,10 @@ export function webhooks(options = {}) {
         const owner = ownerFor(c);
         if (!owner)
             return unauthorized(c);
+        const access = accessFor(c);
         const { id } = c.req.valid('param');
         try {
-            const deleted = await Webhooks.deleteSubscription(db, owner, id);
+            const deleted = await Webhooks.deleteSubscription(db, owner, id, { access });
             if (!deleted)
                 return notFound(c);
             return c.json(Response.validated(schema.deleteWebhook.Response, { id }), 200);
@@ -1310,459 +1391,6 @@ export function webhooks(options = {}) {
         }
     }));
 }
-/**
- * Largest representable in-block index, used as an end-of-block cursor sentinel
- * so a fully-scanned block advances the cursor strictly past it (no row index
- * can equal it).
- */
-const endOfBlockIndex = 2_147_483_647;
-const scanPageSize = 100;
-/** Concurrent per-subscription scans and cursor writes per poll round; caps RPC and DB fan-out. */
-const pollConcurrency = 8;
-/** Event types scanned together when their combined state fits one existing scan round. */
-const pollEventTypeConcurrency = 2;
-/** Maximum subscription states retained by concurrent event-type scan batches. */
-const pollStateLimit = WebhookTransfer.scanCohortSize * pollConcurrency;
-/** Schedules asynchronous work through one shared concurrency bound. */
-function createLimiter(limit) {
-    let active = 0;
-    const waiting = [];
-    return async (fn) => {
-        if (active >= limit)
-            await new Promise((resolve) => waiting.push(resolve));
-        else
-            active++;
-        try {
-            return await fn();
-        }
-        finally {
-            const next = waiting.shift();
-            if (next)
-                next();
-            else
-                active--;
-        }
-    };
-}
-/** Runs `fn` over `items` with at most `limit` in flight, preserving order. */
-async function mapWithLimit(items, limit, fn) {
-    const results = [];
-    let next = 0;
-    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
-        while (next < items.length) {
-            const index = next++;
-            try {
-                results[index] = { status: 'fulfilled', value: await fn(items[index]) };
-            }
-            catch (reason) {
-                results[index] = { reason, status: 'rejected' };
-            }
-        }
-    }));
-    return results;
-}
-/** Returns `candidate` only when it is lexicographically after `current`. */
-function laterCursor(current, candidate) {
-    const before = Cursor.decode(current, ['int', 'int']);
-    const after = Cursor.decode(candidate, ['int', 'int']);
-    if (!after)
-        return current;
-    if (!before)
-        return candidate;
-    const [beforeBlock, beforeIndex] = before;
-    const [afterBlock, afterIndex] = after;
-    return afterBlock > beforeBlock || (afterBlock === beforeBlock && afterIndex > beforeIndex)
-        ? candidate
-        : current;
-}
-/**
- * Polls the chain over RPC for new events and dispatches a signed envelope per
- * matching row, advancing each active subscription's `(block, index)` keyset
- * cursor.
- *
- * Every event type scans a **narrow confirmed window** `[cursor, head -
- * confirmations]` directly over JSON-RPC (`eth_getLogs`,
- * `eth_getBlockByNumber`) so webhook delivery does not wait for an indexer.
- *
- * The chain head is injectable (tests pin a fixed historical window); only
- * blocks at least `confirmations` behind head are emitted, giving at-least-once,
- * finalized-ish semantics (re-delivery overlap is harmless because the receiver
- * dedupes on the stable `event.id`).
- *
- * Cursor advances only past successfully dispatched rows, so a dispatch failure
- * pauses that subscription at the last good position and the next tick resumes.
- * Scan failures leave that subscription unchanged; the first error is rethrown
- * after the remaining subscriptions run.
- */
-export async function poll(options) {
-    const { batchSize = 200, cache: cache_metadata = Store.memory(), chainId, client, confirmations = 1, db, eventTypes: eventTypes_input = [
-        'token:transfer',
-        'transaction:included',
-        'log:emitted',
-        'block:created',
-    ], maxBlocks = 1_000, } = options;
-    const now = options.now ?? (() => new Date());
-    options.signal?.throwIfAborted();
-    // Default (self-host) transport: deliver inline and record the outcome so a
-    // sustained-failure subscription auto-disables. On Cloudflare, callers pass a
-    // Queue producer instead and the consumer runs `deliverAndRecord`.
-    const dispatch = options.dispatch ??
-        (({ envelope, subscription }) => Webhooks.deliverAndRecord(db, subscription, envelope));
-    const dispatchBatch = options.dispatchBatch;
-    // A pinned `headBlockNumber` lets a head subscription supply the exact live
-    // boundary and keeps historical tests deterministic.
-    const override = options.headBlockNumber;
-    let rpcHead = override === undefined ? undefined : Number(override);
-    const resolveRpcHead = async () => (rpcHead ??= await getRpcHead(client));
-    const headStartedAt = Date.now();
-    const rpcSafeBlock = await (async () => {
-        try {
-            const safeBlock = Math.max(0, (await resolveRpcHead()) - confirmations);
-            options.onStage?.({
-                durationMs: Date.now() - headStartedAt,
-                outcome: 'ok',
-                stage: 'rpc_head',
-            });
-            return safeBlock;
-        }
-        catch (error) {
-            options.onStage?.({
-                durationMs: Date.now() - headStartedAt,
-                outcome: 'error',
-                stage: 'rpc_head',
-            });
-            throw error;
-        }
-    })();
-    const result = {
-        chainId,
-        dispatched: 0,
-        failed: 0,
-        safeBlock: rpcSafeBlock,
-        scanned: 0,
-        subscriptions: 0,
-    };
-    let cursorLagBlocks = 0;
-    const pollErrors = [];
-    const eventTypes = [...new Set(eventTypes_input)];
-    const subscriptionsStartedAt = Date.now();
-    const pairs = await Webhooks.listActiveForChain(db, { chainId, eventTypes });
-    options.signal?.throwIfAborted();
-    options.onSubscriptions?.(pairs.length);
-    options.onStage?.({
-        durationMs: Date.now() - subscriptionsStartedAt,
-        outcome: 'ok',
-        stage: 'subscription_read',
-    });
-    const pairsByEventType = Map.groupBy(pairs, (pair) => pair.subscription.eventType);
-    const eventTypes_active = eventTypes.filter((eventType) => (pairsByEventType.get(eventType)?.length ?? 0) > 0);
-    const eventTypeConcurrency = pairs.length <= pollStateLimit
-        ? Math.min(pollEventTypeConcurrency, eventTypes_active.length)
-        : Math.min(1, eventTypes_active.length);
-    const scanRoundSize = Math.floor(pollStateLimit / Math.max(1, eventTypeConcurrency));
-    const scheduleScan = createLimiter(pollConcurrency);
-    const eventTypeResults = await mapWithLimit(eventTypes_active, eventTypeConcurrency, async (eventType) => {
-        options.signal?.throwIfAborted();
-        const safeBlock = rpcSafeBlock;
-        const pairs = pairsByEventType.get(eventType) ?? [];
-        const durations = {
-            cursor_write: 0,
-            enrich: 0,
-            scan: 0,
-        };
-        const observed = new Set();
-        let cursorWriteOutcome = 'ok';
-        let scanOutcome = 'ok';
-        const writeCursor = async (parameters) => {
-            const startedAt = Date.now();
-            observed.add('cursor_write');
-            try {
-                return await Webhooks.compareAndSetCursor(db, parameters);
-            }
-            catch (error) {
-                cursorWriteOutcome = 'error';
-                pollErrors.push(error);
-                return false;
-            }
-            finally {
-                durations.cursor_write += Date.now() - startedAt;
-            }
-        };
-        let states = [];
-        for (const pair of pairs) {
-            const { subscription } = pair;
-            result.subscriptions++;
-            let filters;
-            try {
-                filters = parseFilters(subscription.eventType, subscription.filters);
-            }
-            catch (error) {
-                if (!(error instanceof Webhooks.InvalidFilterError))
-                    throw error;
-                options.signal?.throwIfAborted();
-                // A breaking filter-schema removal must not poison every chain poll.
-                // Disable the legacy subscription without widening its match set.
-                await Webhooks.updateSubscription(db, subscription.owner, subscription.id, {
-                    status: 'disabled',
-                });
-                continue;
-            }
-            let cursor = pair.cursor;
-            if (cursor === null) {
-                // Legacy subscriptions without a creation checkpoint anchor at the
-                // current confirmed head, avoiding a genesis backfill.
-                await writeCursor({
-                    cursor: Cursor.encode([safeBlock, endOfBlockIndex]),
-                    expectedCursor: null,
-                    subscriptionId: subscription.id,
-                });
-                continue;
-            }
-            const checkpoint = Cursor.decode(cursor, ['int']);
-            if (checkpoint) {
-                // Creation checkpoints record the live head without finalizing it. Rebase
-                // to this poller's confirmed boundary so replacement blocks stay eligible.
-                const confirmedCursor = Cursor.encode([
-                    Math.max(0, checkpoint[0] - confirmations),
-                    endOfBlockIndex,
-                ]);
-                const committed = await writeCursor({
-                    cursor: confirmedCursor,
-                    expectedCursor: cursor,
-                    subscriptionId: subscription.id,
-                });
-                if (!committed)
-                    continue;
-                cursor = confirmedCursor;
-            }
-            const position = Cursor.decode(cursor, ['int', 'int']);
-            if (position)
-                cursorLagBlocks = Math.max(cursorLagBlocks, safeBlock - position[0]);
-            const window = scanWindow(cursor, safeBlock, maxBlocks);
-            if (window && window.to < safeBlock)
-                result.hasMore = true;
-            states.push({
-                cursor,
-                filters,
-                remaining: batchSize,
-                safeBlock: window?.to ?? safeBlock,
-                subscription,
-            });
-        }
-        // Every subscription gets one bounded page before any subscription gets a
-        // continuation page, preserving fairness while allowing catch-up.
-        while (states.length > 0) {
-            options.signal?.throwIfAborted();
-            const continuations = [];
-            const round = states;
-            for (let offset = 0; offset < round.length; offset += scanRoundSize) {
-                const batch = round.slice(offset, offset + scanRoundSize);
-                const windows = batch.flatMap((state) => {
-                    const window = scanWindow(state.cursor, state.safeBlock, maxBlocks);
-                    return window ? [window] : [];
-                });
-                const maxWindowBlocks = Math.max(0, ...windows.map((window) => window.to - window.from + 1));
-                const totalWindowBlocks = windows.reduce((total, window) => total + window.to - window.from + 1, 0);
-                options.onScanCheckpoint?.({
-                    concurrency: pollConcurrency,
-                    eventType,
-                    maxWindowBlocks,
-                    phase: 'start',
-                    rpcMethod: scanRpcMethod(eventType),
-                    subscriptionLimit: scanRoundSize,
-                    subscriptionCount: batch.length,
-                    totalWindowBlocks,
-                });
-                const scanStartedAt = Date.now();
-                const pages = await scanSubscriptions({
-                    client,
-                    eventType,
-                    maxBlocks,
-                    schedule: scheduleScan,
-                    states: batch,
-                });
-                options.onScanCheckpoint?.({
-                    concurrency: pollConcurrency,
-                    durationMs: Date.now() - scanStartedAt,
-                    eventType,
-                    failedSubscriptions: pages.filter((page) => page.status === 'rejected').length,
-                    matchedItems: pages.reduce((total, page) => total + (page.status === 'fulfilled' ? page.value.items.length : 0), 0),
-                    maxWindowBlocks,
-                    outcome: scanResultOutcome(pages),
-                    phase: 'complete',
-                    rpcMethod: scanRpcMethod(eventType),
-                    subscriptionLimit: scanRoundSize,
-                    subscriptionCount: batch.length,
-                    totalWindowBlocks,
-                });
-                options.signal?.throwIfAborted();
-                durations.scan += Date.now() - scanStartedAt;
-                observed.add('scan');
-                if (pages.some((page) => page.status === 'rejected'))
-                    scanOutcome = 'error';
-                const busy = [];
-                const idle = [];
-                for (let i = 0; i < batch.length; i++) {
-                    const state = batch[i];
-                    const settled = pages[i];
-                    if (settled.status === 'rejected') {
-                        pollErrors.push(settled.reason);
-                        continue;
-                    }
-                    result.scanned += settled.value.items.length;
-                    state.remaining -= settled.value.items.length;
-                    (settled.value.items.length > 0 ? busy : idle).push({ page: settled.value, state });
-                }
-                // Empty pages only advance their cursor: no dispatch order to preserve,
-                // so one statement commits the cohort while retaining per-row CAS semantics.
-                const cursorWritesStartedAt = Date.now();
-                const candidates = idle.flatMap(({ page, state }) => {
-                    options.signal?.throwIfAborted();
-                    const candidate = page.scannedThrough !== undefined
-                        ? Cursor.encode([page.scannedThrough, endOfBlockIndex])
-                        : page.hasMore
-                            ? undefined
-                            : Cursor.encode([state.safeBlock, endOfBlockIndex]);
-                    const cursor = candidate ? laterCursor(state.cursor, candidate) : state.cursor;
-                    return cursor === state.cursor ? [] : [{ cursor, state }];
-                });
-                if (candidates.length > 0) {
-                    const committed = await (async () => {
-                        try {
-                            return await Webhooks.compareAndSetCursors(db, {
-                                cursors: candidates.map(({ cursor, state }) => ({
-                                    cursor,
-                                    expectedCursor: state.cursor,
-                                    subscriptionId: state.subscription.id,
-                                })),
-                            });
-                        }
-                        catch (error) {
-                            cursorWriteOutcome = 'error';
-                            pollErrors.push(error);
-                            return new Set();
-                        }
-                    })();
-                    for (const { cursor, state } of candidates)
-                        if (committed.has(state.subscription.id))
-                            state.cursor = cursor;
-                    durations.cursor_write += Date.now() - cursorWritesStartedAt;
-                    observed.add('cursor_write');
-                }
-                for (const { page, state } of busy) {
-                    options.signal?.throwIfAborted();
-                    const { subscription } = state;
-                    let accepted;
-                    let failed = false;
-                    const buildDispatchable = async (item) => {
-                        options.signal?.throwIfAborted();
-                        // Token metadata is best-effort for webhooks: transfers use it for display,
-                        // while transactions expose fee-token references without blocking delivery.
-                        const enrichStartedAt = Date.now();
-                        const data = await enrichEventData(eventType, item.data, {
-                            cache: cache_metadata,
-                            chainId,
-                            client,
-                        });
-                        durations.enrich += Date.now() - enrichStartedAt;
-                        observed.add('enrich');
-                        options.signal?.throwIfAborted();
-                        const envelope = Webhooks.buildEnvelope({
-                            blockNumber: item.cursor[0],
-                            createdAt: now(),
-                            data,
-                            logIndex: item.cursor[1],
-                            subscription,
-                        });
-                        return { envelope, subscription };
-                    };
-                    if (dispatchBatch) {
-                        const dispatchables = [];
-                        for (const item of page.items)
-                            dispatchables.push(await buildDispatchable(item));
-                        options.signal?.throwIfAborted();
-                        const delivered = await dispatchBatch(dispatchables, { db });
-                        if (delivered.ok) {
-                            accepted = page.items.at(-1)?.cursor;
-                            result.dispatched += dispatchables.length;
-                        }
-                        else {
-                            result.failed += dispatchables.length;
-                            failed = true;
-                        }
-                    }
-                    else {
-                        for (const item of page.items) {
-                            const dispatchable = await buildDispatchable(item);
-                            const delivered = await dispatch(dispatchable);
-                            if (!delivered.ok) {
-                                result.failed++;
-                                failed = true;
-                                break;
-                            }
-                            accepted = item.cursor;
-                            result.dispatched++;
-                        }
-                    }
-                    // Persist every accepted page before another subscription begins its
-                    // continuation, so a later scan failure retains completed work.
-                    const candidate = (() => {
-                        if (failed)
-                            return accepted ? Cursor.encode([...accepted]) : undefined;
-                        if (page.scannedThrough !== undefined)
-                            return Cursor.encode([page.scannedThrough, endOfBlockIndex]);
-                        if (accepted)
-                            return Cursor.encode([...accepted]);
-                        if (!page.hasMore)
-                            return Cursor.encode([state.safeBlock, endOfBlockIndex]);
-                        return undefined;
-                    })();
-                    const cursor = candidate ? laterCursor(state.cursor, candidate) : state.cursor;
-                    const progressed = cursor !== state.cursor;
-                    let committed = false;
-                    if (progressed) {
-                        committed = await writeCursor({
-                            cursor,
-                            expectedCursor: state.cursor,
-                            subscriptionId: subscription.id,
-                        });
-                        if (committed)
-                            state.cursor = cursor;
-                    }
-                    if (!failed && page.hasMore === true) {
-                        if (committed && state.remaining > 0)
-                            continuations.push(state);
-                        else
-                            result.hasMore = true;
-                    }
-                }
-            }
-            states = continuations;
-        }
-        for (const stage of observed) {
-            const outcome = (() => {
-                if (stage === 'cursor_write')
-                    return cursorWriteOutcome;
-                if (stage === 'scan')
-                    return scanOutcome;
-                return 'ok';
-            })();
-            options.onStage?.({
-                durationMs: durations[stage],
-                eventType,
-                outcome,
-                stage,
-            });
-        }
-    });
-    for (const result of eventTypeResults)
-        if (result.status === 'rejected')
-            pollErrors.push(result.reason);
-    options.onCursorLag?.(cursorLagBlocks);
-    if (pollErrors.length > 0)
-        throw pollErrors[0];
-    return result;
-}
 /**
  * Attaches best-effort `{ symbol, decimals }` token metadata to a
  * `token:transfer` row so destinations can render human amounts. Reads the row's
@@ -1849,62 +1477,9 @@ async function withFeeTokenMetadata(data, deps) {
 export async function getRpcHead(client) {
     return Number(await client.getBlockNumber());
 }
-/** Groups aligned cursors only when their bounded upstream scans are equivalent. */
-async function scanSubscriptions(options) {
-    const { client, eventType, maxBlocks, schedule, states } = options;
-    if (eventType !== 'token:transfer')
-        return scanIndependent({ client, eventType, maxBlocks, schedule, states });
-    return WebhookTransfer.scan({
-        client,
-        concurrency: pollConcurrency,
-        maxBlocks,
-        schedule,
-        states: states.map((state) => ({
-            filters: state.filters,
-            limit: Math.min(scanPageSize, state.remaining),
-            window: scanWindow(state.cursor, state.safeBlock, maxBlocks),
-        })),
-    });
-}
-/** Returns the bounded JSON-RPC method used by an event scanner. */
-function scanRpcMethod(eventType) {
-    return eventType === 'block:created' || eventType === 'transaction:included'
-        ? 'eth_getBlockByNumber'
-        : 'eth_getLogs';
-}
-/** Classifies a completed batch without exposing an unbounded upstream error. */
-function scanResultOutcome(pages) {
-    const rejected = pages.filter((page) => page.status === 'rejected');
-    if (rejected.some((page) => page.reason instanceof BlockUnavailableError))
-        return 'missing';
-    if (rejected.length > 0)
-        return 'error';
-    return pages.every((page) => page.status === 'fulfilled' && page.value.items.length === 0)
-        ? 'empty'
-        : 'ok';
-}
-/** Scans CPU-matched streams per subscription while sharing concurrent block reads. */
-function scanIndependent(options) {
-    const { client, eventType, maxBlocks, schedule, states } = options;
-    const cache = createChainCache(client);
-    return mapWithLimit(states, pollConcurrency, (state) => schedule(() => {
-        const shared = {
-            batchSize: Math.min(scanPageSize, state.remaining),
-            cache,
-            cursor: state.cursor,
-            filters: state.filters,
-            maxBlocks,
-            safeBlock: state.safeBlock,
-        };
-        if (eventType === 'block:created')
-            return scanBlocks(shared);
-        if (eventType === 'log:emitted')
-            return scanLogs({ ...shared, client });
-        return scanTxs(shared);
-    }));
-}
 const filterSchemas = {
     'block:created': schema.BlockFilters,
+    'funding:deposit.updated': schema.FundingDepositFilters,
     'log:emitted': schema.LogFilters,
     'token:transfer': schema.TransferFilters,
     'transaction:included': schema.TxFilters,
@@ -1912,7 +1487,7 @@ const filterSchemas = {
 /**
  * Validates `filters` against the schema for `eventType`, **failing closed**: an
  * invalid filter throws {@link Webhooks.InvalidFilterError} instead of degrading
- * to `{}` (a firehose). Used at create/patch time and by the scanners so a stored
+ * to `{}` (a firehose). Used at create/patch time and by {@link scanBlock} so a stored
  * bad filter can never silently widen the match set.
  */
 export function parseFilters(eventType, filters) {
@@ -1962,7 +1537,7 @@ function operandEquals(value, target, kind) {
  * The JS counterpart of the old SQL `applyOperator`: evaluates one parsed filter
  * operator (from {@link schema.eq}/{@link schema.compare}/{@link schema.bytes})
  * against a single `0x`-hex field value pulled from an RPC object. The one place
- * operator semantics live, shared by every RPC scanner. Returns `false` for a
+ * operator semantics live, shared by every event matcher. Returns `false` for a
  * missing field so an absent value never matches (fail-closed).
  *
  * - bare value / `{ eq }` → equality
@@ -2021,74 +1596,10 @@ function matchesCalls(calls, op) {
     }
     return has(op);
 }
-// RPC window helpers + per-tick lazy cache.
-/** Renders a block number as a `0x`-hex tag for JSON-RPC params. */
-const blockTag = (n) => `0x${n.toString(16)}`;
-/** Issues a JSON-RPC request through the viem client for a method viem can't type. */
-function rpc(client, method, params) {
-    return client.request({
-        method,
-        params: [...params],
-    });
-}
 /**
- * The confirmed scan window for a cursor. A cursor `(cb, ci)` means rows through
- * `(cb, ci)` were dispatched: when `ci` is the end-of-block sentinel the whole
- * block `cb` is done and scanning resumes at `cb + 1`; otherwise block `cb` is
- * re-scanned (skipping indices `<= ci`). `to` is capped by both `safeBlock` and
- * the per-tick backfill cap. Returns `undefined` when the subscription is
- * already caught up (nothing to scan, cursor unchanged).
- */
-function scanWindow(cursor, safeBlock, maxBlocks) {
-    const decoded = cursor ? Cursor.decode(cursor, ['int', 'int']) : undefined;
-    const cb = decoded ? decoded[0] : 0;
-    const ci = decoded ? decoded[1] : endOfBlockIndex;
-    const from = ci >= endOfBlockIndex ? cb + 1 : cb;
-    if (from > safeBlock)
-        return undefined;
-    const to = Math.min(safeBlock, from + maxBlocks - 1);
-    return { from, skip: [cb, ci], to };
-}
-/** True when `(block, index)` is at or before the already-dispatched cursor. */
-function atOrBefore(block, index, skip) {
-    return block < skip[0] || (block === skip[0] && index <= skip[1]);
-}
-/** Builds a per-batch {@link ChainCache} bound to a viem client. */
-function createChainCache(client) {
-    const headers = new Map();
-    const blocks = new Map();
-    const singleFlight = (pending, key, load) => {
-        const existing = pending.get(key);
-        if (existing)
-            return existing;
-        const promise = load().finally(() => pending.delete(key));
-        pending.set(key, promise);
-        return promise;
-    };
-    return {
-        block(n) {
-            return singleFlight(blocks, n, () => 
-            // The transaction payload reuses `humanizeTransaction`, which consumes
-            // the raw RPC tx shape, so the full block stays on the untyped path.
-            rpc(client, 'eth_getBlockByNumber', [
-                blockTag(n),
-                true,
-            ]).then((block) => {
-                if (!block)
-                    throw new BlockUnavailableError(n);
-                return block;
-            }));
-        },
-        header(n) {
-            return singleFlight(headers, n, () => client.getBlock({ blockNumber: BigInt(n), includeTransactions: false }));
-        },
-    };
-}
-/**
- * Builds the delivered `log:emitted` payload from a viem-formatted log plus the
+ * Builds the delivered `log:emitted` payload from a viem-shaped log plus the
  * block timestamp. Returns `undefined` when a required field is missing/invalid
- * (the row is skipped). When a `signature`/`event` is supplied, `getLogs` has
- * already decoded `args`/`eventName`, so this just serializes them.
+ * (the row is skipped). Decoded `args`/`eventName` are serialized when present.
  */
 function toLogEvent(log, timestamp, signature, event) {
     const address = Schema.Address.safeParse(log.address);
@@ -2153,7 +1664,7 @@ function pushHex(op) {
         return value;
     return undefined;
 }
-/** Narrows an `eq`/`in` address operator into the `getLogs` address pushdown. */
+/** Narrows an `eq`/`in` address operator into a pushdown-capable address value. */
 function pushAddress(op) {
     return pushHex(op);
 }
@@ -2169,7 +1680,7 @@ function parseEvent(signature) {
         return undefined;
     }
 }
-/** Returns exact indexed arguments that viem can push into `eth_getLogs`. */
+/** Returns exact indexed arguments usable as a selective log anchor. */
 function pushEventArgs(args, event) {
     const pushed = {};
     for (const [name, op] of Object.entries(args ?? {})) {
@@ -2180,7 +1691,7 @@ function pushEventArgs(args, event) {
     }
     return pushed;
 }
-/** Checks that the accepted filter has a selective `eth_getLogs` representation. */
+/** Checks that the accepted filter carries a selective anchor rather than matching every log. */
 function hasLogPushdown(f) {
     if (pushAddress(f.address) !== undefined)
         return true;
@@ -2190,19 +1701,7 @@ function hasLogPushdown(f) {
         return secondaryTopic || Object.keys(pushEventArgs(f.args, event)).length > 0;
     return pushHex(f.topic0) !== undefined && secondaryTopic;
 }
-/** Builds raw topic filters, preserving null wildcards between constrained positions. */
-function pushTopics(f, event) {
-    const topics = [
-        event ? encodeEventTopics({ abi: [event] })[0] : pushHex(f.topic0),
-        pushHex(f.topic1),
-        pushHex(f.topic2),
-        pushHex(f.topic3),
-    ];
-    while (topics.length > 0 && topics.at(-1) === undefined)
-        topics.pop();
-    return topics.map((topic) => topic ?? null);
-}
-/** Converts one raw JSON-RPC log into the viem-shaped scanner input. */
+/** Converts one raw JSON-RPC log into the viem-shaped matcher input. */
 function fromRpcLog(log) {
     return {
         address: log.address,
@@ -2244,64 +1743,6 @@ export async function enrichEventData(eventType, data, options) {
         return withFeeTokenMetadata(data, options);
     return data;
 }
-/** Scans contract logs for one subscription, then re-checks every filter in memory. */
-async function scanLogs(options) {
-    const { batchSize, cache, client, cursor, filters, maxBlocks, safeBlock } = options;
-    const f = filters;
-    const window = scanWindow(cursor, safeBlock, maxBlocks);
-    if (!window)
-        return { items: [], scannedThrough: undefined };
-    const event = parseEvent(f.signature);
-    if (f.signature && (!event || !/^[A-Za-z_]\w*$/.test(event.name)))
-        throw new Webhooks.InvalidFilterError('log:emitted', [
-            { message: 'Unsupported event signature.', path: ['signature'] },
-        ]);
-    const address = pushAddress(f.address);
-    const topics = pushTopics(f, event);
-    const hasRawTopics = topics.slice(1).some((topic) => topic !== null);
-    const args = event ? pushEventArgs(f.args, event) : {};
-    const logs = (!event || hasRawTopics
-        ? (await rpc(client, 'eth_getLogs', [
-            {
-                ...(address ? { address } : {}),
-                fromBlock: blockTag(window.from),
-                ...(topics.length > 0 ? { topics } : {}),
-                toBlock: blockTag(window.to),
-            },
-        ]))
-            .map(fromRpcLog)
-            .map((log) => (event ? decodeScanLog(log, event) : log))
-        : await client.getLogs({
-            ...(address ? { address } : {}),
-            ...(Object.keys(args).length > 0 ? { args: args } : {}),
-            event,
-            fromBlock: BigInt(window.from),
-            strict: false,
-            toBlock: BigInt(window.to),
-        }));
-    logs.sort((a, b) => {
-        const block = Number(a.blockNumber ?? 0n) - Number(b.blockNumber ?? 0n);
-        return block || (a.logIndex ?? 0) - (b.logIndex ?? 0);
-    });
-    const items = [];
-    for (const log of logs) {
-        const blockNumber = log.blockNumber === null ? undefined : Number(log.blockNumber);
-        const logIndex = log.logIndex ?? undefined;
-        if (blockNumber === undefined || logIndex === undefined)
-            continue;
-        if (atOrBefore(blockNumber, logIndex, window.skip))
-            continue;
-        if (!matchesLog(log, f, event))
-            continue;
-        const data = toLogEvent(log, Value.blockToIso(await cache.header(blockNumber)), f.signature, event);
-        if (data) {
-            items.push({ cursor: [data.blockNumber, data.logIndex], data });
-            if (items.length >= batchSize)
-                return { hasMore: true, items };
-        }
-    }
-    return { items, scannedThrough: window.to };
-}
 /** Re-checks all log filters (including non-pushable operators) in JS. */
 function matchesLog(log, f, event) {
     const topics = log.topics;
@@ -2315,8 +1756,8 @@ function matchesLog(log, f, event) {
     if (f.blockNumber !== undefined &&
         !matchesOperator(log.blockNumber?.toString(), f.blockNumber, 'number'))
         return false;
-    // `getLogs(event)` already anchors topic0 on the event selector, so the raw
-    // `topic0` operator only applies in raw (no-signature) mode.
+    // With a signature, topic0 is anchored on the event selector above, so the
+    // raw `topic0` operator only applies in raw (no-signature) mode.
     if (!event && f.topic0 !== undefined && !matchesOperator(topics[0], f.topic0))
         return false;
     if (f.topic1 !== undefined && !matchesOperator(topics[1], f.topic1))
@@ -2326,7 +1767,7 @@ function matchesLog(log, f, event) {
     if (f.topic3 !== undefined && !matchesOperator(topics[3], f.topic3))
         return false;
     if (event && f.args && Object.keys(f.args).length > 0) {
-        // `getLogs(event, strict:false)` keeps non-decodable matches with no `args`.
+        // Best-effort decoding leaves a non-decodable log without `args`.
         if (log.args === undefined || Array.isArray(log.args))
             return false;
         const args = log.args;
@@ -2374,31 +1815,6 @@ function toBlockEvent(block) {
         transactionCount,
     };
 }
-/** Scans new blocks over one subscription's confirmed window. */
-async function scanBlocks(options) {
-    const { batchSize, cache, cursor, filters, maxBlocks, safeBlock } = options;
-    const f = filters;
-    const window = scanWindow(cursor, safeBlock, maxBlocks);
-    if (!window)
-        return { items: [], scannedThrough: undefined };
-    const items = [];
-    for (let blockNumber = window.from; blockNumber <= window.to; blockNumber++) {
-        if (atOrBefore(blockNumber, 0, window.skip))
-            continue;
-        const block = await cache.header(blockNumber);
-        if (!block)
-            continue;
-        if (!matchesBlock(block, f))
-            continue;
-        const data = toBlockEvent(block);
-        if (data) {
-            items.push({ cursor: [data.number, 0], data });
-            if (items.length >= batchSize)
-                return { hasMore: true, items };
-        }
-    }
-    return { items, scannedThrough: window.to };
-}
 /** Re-checks all block filters in JS. The RPC has no consensus `proposer`. */
 function matchesBlock(block, f) {
     if (f.number !== undefined && !matchesOperator(block.number?.toString(), f.number, 'number'))
@@ -2418,7 +1834,7 @@ function matchesBlock(block, f) {
         return false;
     return true;
 }
-// transaction:included (eth_getBlockByNumber)
+// transaction:included
 /** Maps a `transaction:included` scalar filter field to its raw-tx field + kind. */
 const txFields = {
     blockNumber: { field: 'blockNumber', kind: 'number' },
@@ -2434,43 +1850,6 @@ const txFields = {
     validBefore: { field: 'validBefore', kind: 'number' },
     value: { field: 'value', kind: 'number' },
 };
-/** Scans included transactions over one subscription's confirmed window. */
-async function scanTxs(options) {
-    const { batchSize, cache, cursor, filters, maxBlocks, safeBlock } = options;
-    const f = filters;
-    const window = scanWindow(cursor, safeBlock, maxBlocks);
-    if (!window)
-        return { items: [], scannedThrough: undefined };
-    const includeCalls = f.includeCalls ?? true;
-    const items = [];
-    for (let blockNumber = window.from; blockNumber <= window.to; blockNumber++) {
-        const block = await cache.block(blockNumber);
-        const transactions = Array.isArray(block['transactions'])
-            ? block['transactions']
-            : [];
-        const timestamp = asString(block['timestamp']);
-        // A transaction's own `blockTimestamp` is seconds-only, so the delivered
-        // timestamp comes from the enclosing block, which carries milliseconds.
-        const blockTime = Value.blockToIso(block);
-        for (let offset = 0; offset < transactions.length; offset++) {
-            const transaction = transactions[offset];
-            const transactionIndex = Value.hexToNumber(transaction['transactionIndex']) ?? offset;
-            if (atOrBefore(blockNumber, transactionIndex, window.skip))
-                continue;
-            if (!matchesTx(transaction, f, includeCalls, timestamp, blockNumber))
-                continue;
-            const parsed = Transactions.schema.Rpc.Transaction.safeParse(transaction);
-            if (!parsed.success)
-                continue;
-            const humanized = Transactions.humanizeTransaction(parsed.data);
-            const data = blockTime === undefined ? humanized : { ...humanized, timestamp: blockTime };
-            items.push({ cursor: [blockNumber, transactionIndex], data });
-            if (items.length >= batchSize)
-                return { hasMore: true, items };
-        }
-    }
-    return { items, scannedThrough: window.to };
-}
 /** Re-checks transaction filters against the raw RPC transaction. */
 function matchesTx(tx, f, includeCalls, timestamp, blockNumber) {
     const from = tx['from'];
@@ -2524,6 +1903,16 @@ function ownerFor(c) {
     const payer = principal.payment?.payer;
     return payer ? { payer, type: 'mpp' } : null;
 }
+function accessFor(c) {
+    const principal = Auth.getPrincipal(c);
+    if (principal?.type !== 'api_key')
+        throw new Error('Webhook routes require an API key.');
+    return {
+        environment: principal.environment,
+        ...(principal.projectId === undefined ? {} : { projectId: principal.projectId }),
+        scopes: principal.apiKey.scopes,
+    };
+}
 /** Strips internal fields (`owner`, `secret`) from a subscription for reads. */
 function toPublic(subscription) {
     return {
@@ -2531,6 +1920,10 @@ function toPublic(subscription) {
         ...(subscription.context === undefined ? {} : { context: subscription.context }),
         createdAt: subscription.createdAt,
         destination: redactDestination(subscription.destination),
+        ...(subscription.eventType === 'funding:deposit.updated' &&
+            subscription.environment !== undefined
+            ? { environment: subscription.environment }
+            : {}),
         eventType: subscription.eventType,
         ...(subscription.expiresAt === undefined ? {} : { expiresAt: subscription.expiresAt }),
         failureCount: subscription.failureCount,
@@ -2762,10 +2155,4 @@ function toScanHeader(block) {
         timestamp: quantity(block['timestamp']),
     };
 }
-class BlockUnavailableError extends Error {
-    name = 'Webhooks.BlockUnavailableError';
-    constructor(blockNumber) {
-        super(`Block ${blockNumber} is unavailable.`);
-    }
-}
 //# sourceMappingURL=webhooks.js.map