tapimo 0.14.0 → 0.15.1

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

@@ -14,8 +14,8 @@ 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 FundingTransfer from '../../../internal/funding/Transfer.js';
+import * as RoutesDeposit from '../../../internal/routes/Deposit.js';
+import * as RoutesTransfer from '../../../internal/routes/Transfer.js';
 import * as Transactions from './transactions.js';
 import * as Transfers from './transfers.js';
 /** Default cap on live subscriptions per owner, overridable via `webhook.maxPerOwner`. */
@@ -35,20 +35,20 @@ const redactedSlackUrl = 'https://hooks.slack.com/…';
  */
 export const eventTypes = [
     'block:created',
-    'funding:deposit.updated',
-    'funding:transfer.updated',
+    'routes:deposit.updated',
+    'routes:transfer.updated',
     'log:emitted',
     'token:transfer',
     'transaction:included',
 ];
-/** Funding resource events produced by the API instead of chain scans. */
-export const fundingEventTypes = [
-    'funding:deposit.updated',
-    'funding:transfer.updated',
+/** Route resource events produced by the API instead of chain scans. */
+export const routesEventTypes = [
+    'routes:deposit.updated',
+    'routes:transfer.updated',
 ];
-/** Returns whether an event type carries an owner-scoped funding resource. */
-export function isFundingEventType(eventType) {
-    return fundingEventTypes.includes(eventType);
+/** Returns whether an event type carries an owner-scoped route resource. */
+export function isRoutesEventType(eventType) {
+    return routesEventTypes.includes(eventType);
 }
 /** Subscribable event types surfaced by `GET /webhooks/event-types`. */
 const eventTypeDescriptions = [
@@ -57,12 +57,12 @@ const eventTypeDescriptions = [
         type: 'block:created',
     },
     {
-        description: 'A funding deposit materially changed after verified reconciliation, filterable by deposit address, recipient, or status.',
-        type: 'funding:deposit.updated',
+        description: 'A route deposit materially changed after verified reconciliation, filterable by deposit address, recipient, or status.',
+        type: 'routes:deposit.updated',
     },
     {
-        description: 'A funding transfer materially changed, filterable by transfer ID or lifecycle status.',
-        type: 'funding:transfer.updated',
+        description: 'A route transfer materially changed, filterable by transfer ID or lifecycle status.',
+        type: 'routes:transfer.updated',
     },
     {
         description: 'Any contract event log, filtered by emitting address, event signature/topics, or decoded arguments.',
@@ -81,7 +81,7 @@ const eventTypeDescriptions = [
 export var schema;
 (function (schema) {
     /** Subscribable event type. */
-    schema.EventType = z.enum(eventTypes).check(z.describe('Event type you can subscribe to.'));
+    schema.EventType = OpenApi.component(z.enum(eventTypes).check(z.describe('Event type you can subscribe to.')), 'WebhookSubscriptionEventType');
     /** Subscription lifecycle status. */
     schema.Status = z
         .enum(['active', 'disabled', 'paused'])
@@ -106,42 +106,46 @@ export var schema;
      * your Slack incoming-webhook URL), or a `betterstack` destination (a structured
      * log event POSTed to a Better Stack source with a bearer source token).
      */
-    const Destination = z
+    const DestinationSchema = z
         .discriminatedUnion('type', [
         z.object({
-            type: z.literal('url'),
+            type: z.literal('url').check(z.meta({ examples: ['url'] })),
             url: Url,
         }),
         z.object({
-            type: z.literal('slack'),
+            type: z.literal('slack').check(z.meta({ examples: ['slack'] })),
             url: SlackUrl,
         }),
         z.object({
             token: BetterstackToken,
-            type: z.literal('betterstack'),
+            type: z.literal('betterstack').check(z.meta({ examples: ['betterstack'] })),
             url: BetterstackUrl,
         }),
     ])
-        .check(z.describe('Delivery destination: an HTTPS URL, a Slack incoming-webhook URL, or a Better Stack source.'));
-    const PublicDestination = z
+        .check(z.describe('Delivery destination: an HTTPS URL, a Slack incoming-webhook URL, or a Better Stack source.'), z.meta({ examples: [{ type: 'url', url: 'https://example.com/webhooks' }] }));
+    const Destination = OpenApi.component(DestinationSchema, 'WebhookDestination');
+    const PublicDestinationSchema = z
         .discriminatedUnion('type', [
         z.object({
-            type: z.literal('url'),
+            type: z.literal('url').check(z.meta({ examples: ['url'] })),
             url: Url,
         }),
         z.object({
-            type: z.literal('slack'),
-            url: z.literal(redactedSlackUrl).check(z.describe('Redacted Slack webhook URL.')),
+            type: z.literal('slack').check(z.meta({ examples: ['slack'] })),
+            url: z
+                .literal(redactedSlackUrl)
+                .check(z.describe('Redacted Slack webhook URL.'), z.meta({ examples: [redactedSlackUrl] })),
         }),
         z.object({
             token: z
                 .literal(redactedBetterstackToken)
-                .check(z.describe('Redacted Better Stack source token.')),
-            type: z.literal('betterstack'),
+                .check(z.describe('Redacted Better Stack source token.'), z.meta({ examples: [redactedBetterstackToken] })),
+            type: z.literal('betterstack').check(z.meta({ examples: ['betterstack'] })),
             url: BetterstackUrl,
         }),
     ])
-        .check(z.describe('Delivery destination with bearer credentials redacted.'));
+        .check(z.describe('Delivery destination with bearer credentials redacted.'), z.meta({ examples: [{ type: 'url', url: 'https://example.com/webhooks' }] }));
+    const PublicDestination = OpenApi.component(PublicDestinationSchema, 'WebhookPublicDestination');
     /**
      * Equality / membership operator for a filterable field. A consumer can pass a
      * bare value (shorthand for exact equality, the common case) or an operator
@@ -173,7 +177,7 @@ export var schema;
             lt: z.optional(Schema.Quantity),
             lte: z.optional(Schema.Quantity),
         })
-            .check(z.refine((c) => Object.keys(c).length > 0, { error: 'Comparison cannot be empty.' })),
+            .check(z.refine((c) => Object.keys(c).length > 0, { error: 'Comparison cannot be empty.' }), z.meta({ examples: [{ gte: '0x1' }] })),
     ]);
     /**
      * Byte/calldata-matching operator for hex fields (tx `input`, `calls[].input`).
@@ -191,7 +195,7 @@ export var schema;
      * drift. All are optional and AND-combined; omit every field to subscribe to
      * the full stream.
      */
-    schema.TransferFilters = Transfers.schema.Predicates.check(z.describe('Filters that narrow which TIP-20 transfer events trigger this webhook.'), z.meta({ title: 'Transfer filters' }));
+    schema.TransferFilters = OpenApi.component(Transfers.schema.Predicates.check(z.describe('Filters that narrow which TIP-20 transfer events trigger this webhook.')), 'WebhookTransferFilters');
     /**
      * `transaction:included` subscription filters: operators over every column the
      * `txs` envelope exposes, plus inner account-abstraction `calls` and the
@@ -201,7 +205,7 @@ export var schema;
      * `address` matches either side (`from` OR `to`); when `includeCalls` is set
      * (default), `to`/`address` also match an inner call target (`calls[].to`).
      */
-    schema.TxFilters = z
+    schema.TxFilters = OpenApi.component(z
         .strictObject({
         hash: z.optional(schema.eq(Schema.Hash).check(z.describe('Match this exact transaction hash (or any of several).'))),
         address: z.optional(schema.eq(Schema.Address).check(z.describe('Match transactions where this address is the sender or recipient.'))),
@@ -230,7 +234,7 @@ export var schema;
         blockNumber: z.optional(schema.compare.check(z.describe('Match the block-number bounds.'))),
         timestamp: z.optional(schema.compare.check(z.describe('Match the block timestamp bounds (unix s).'))),
     })
-        .check(z.describe('Filters that narrow which included transactions trigger this webhook.'), z.meta({ title: 'Included-transaction filters' }));
+        .check(z.describe('Filters that narrow which included transactions trigger this webhook.')), 'WebhookTransactionFilters');
     /** A 32-byte log topic (lowercased hex). */
     const topic = Schema.Hash;
     /**
@@ -241,7 +245,7 @@ export var schema;
      * firehose), and an addressless filter must still be selective — an event
      * anchor (`signature`/`topic0`) plus at least one indexed topic or argument.
      */
-    schema.LogFilters = z
+    schema.LogFilters = OpenApi.component(z
         .strictObject({
         address: z.optional(schema.eq(Schema.Address).check(z.describe('Only match logs emitted by this contract address (or any of several).'), z.meta({ examples: ['0x20c0000000000000000000008f5425160ebe5525'] }))),
         signature: z.optional(z.string().check(z.describe('Human-readable ABI event signature used to derive `topic0` and decode `args`, e.g. `event Transfer(address indexed from, address indexed to, uint256 value)`.'), z.meta({
@@ -264,7 +268,9 @@ export var schema;
             .check(z.describe('Match decoded event arguments by name (indexed or non-indexed). Requires `signature`. Each value is an exact value or a super admin object.'), z.meta({ examples: [{ to: '0x9e39034aae71fb89f66061a2602eb6efec271754' }] }))),
         blockNumber: z.optional(schema.compare.check(z.describe('Only match logs within these block-number bounds.'))),
     })
-        .check(z.describe('Filters that narrow which contract event logs trigger this webhook.'), z.meta({ title: 'Log filters' }), z.refine((f) => Object.keys(f).length > 0, {
+        .check(z.describe('Filters that narrow which contract event logs trigger this webhook.'), z.meta({
+        examples: [{ address: '0x20c0000000000000000000008f5425160ebe5525' }],
+    }), z.refine((f) => Object.keys(f).length > 0, {
         error: 'At least one log filter is required.',
     }), z.refine((f) => !(f.signature && f.topic0), {
         error: 'Pass `signature` or `topic0`, not both.',
@@ -272,14 +278,14 @@ export var schema;
         error: '`args` requires `signature` to decode the event.',
     }), z.refine((f) => hasLogPushdown(f), {
         error: 'Log filters must include a pushdown-capable address or an event/topic0 anchor plus an indexed topic or argument.',
-    }));
+    })), 'WebhookLogFilters');
     /**
      * `block:created` subscription filters. All optional and AND-combined; unlike
      * `log:emitted`, an empty filter is allowed — one row per block is a bounded,
      * non-abusive heartbeat feed. Block-level metadata only (no transaction
      * predicates; use `transaction:included` for those).
      */
-    schema.BlockFilters = z
+    schema.BlockFilters = OpenApi.component(z
         .strictObject({
         number: z.optional(schema.compare.check(z.describe('Only match blocks within these block-number bounds.'))),
         miner: z.optional(schema.eq(Schema.Address).check(z.describe('Only match blocks produced by this address (the miner/producer).'), z.meta({ examples: ['0x0000000000000000000000000000000000000000'] }))),
@@ -288,28 +294,28 @@ export var schema;
         gasLimit: z.optional(schema.compare.check(z.describe('Only match blocks whose gas limit is within these bounds.'))),
         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
+        .check(z.describe('Filters that narrow which new blocks trigger this webhook.')), 'WebhookBlockFilters');
+    /** `routes:deposit.updated` subscription filters. All are optional and AND-combined. */
+    schema.RoutesDepositFilters = OpenApi.component(z
         .strictObject({
-        depositAddressId: z.optional(FundingDeposit.schema.Snapshot.shape.depositAddressId),
+        depositAddressId: z.optional(RoutesDeposit.schema.Snapshot.shape.depositAddressId),
         recipient: z.optional(Schema.Address),
-        status: z.optional(FundingDeposit.schema.Status),
+        status: z.optional(RoutesDeposit.schema.Status),
     })
-        .check(z.describe('Filters that narrow which funding deposit changes trigger this webhook.'), z.meta({ title: 'Funding deposit filters' }));
-    /** `funding:transfer.updated` subscription filters. All are optional and AND-combined. */
-    schema.FundingTransferFilters = z
+        .check(z.describe('Filters that narrow which route deposit changes trigger this webhook.')), 'WebhookRoutesDepositFilters');
+    /** `routes:transfer.updated` subscription filters. All are optional and AND-combined. */
+    schema.RoutesTransferFilters = OpenApi.component(z
         .strictObject({
-        id: z.optional(FundingTransfer.schema.FundingTransfer.shape.id),
-        status: z.optional(FundingTransfer.schema.Status),
+        id: z.optional(RoutesTransfer.schema.RoutesTransfer.shape.id),
+        status: z.optional(RoutesTransfer.schema.Status),
     })
-        .check(z.describe('Filters that narrow which funding transfer changes trigger this webhook.'), z.meta({ title: 'Funding transfer filters' }));
+        .check(z.describe('Filters that narrow which route transfer changes trigger this webhook.')), 'WebhookRoutesTransferFilters');
     /**
      * Optional human context describing what a subscription is for. Surfaced by
      * destinations (Slack header + description, Better Stack log fields) and echoed
      * on every delivered event envelope.
      */
-    schema.Context = z
+    schema.Context = OpenApi.component(z
         .object({
         description: z.optional(z
             .string()
@@ -323,15 +329,17 @@ export var schema;
             .string()
             .check(z.maxLength(120), z.describe('Short label for this subscription.'), z.meta({ examples: ['Prod USDC large transfers'] }))),
     })
-        .check(z.describe('Human context describing what this webhook subscription is for.'));
+        .check(z.describe('Human context describing what this webhook subscription is for.')), 'WebhookContext');
     /**
      * Public subscription representation. Never includes the signing `secret`
      * (returned once by `POST /webhooks`) or the internal owner.
      */
-    schema.Subscription = z
+    schema.Subscription = OpenApi.component(z
         .object({
         chainId: chainIdResponse,
-        context: z.optional(schema.Context),
+        context: z
+            .optional(schema.Context)
+            .check(z.meta({ examples: [{ title: 'Prod USDC large transfers' }] })),
         createdAt: z.iso
             .datetime()
             .check(z.describe('When the subscription was created, as an ISO 8601 timestamp.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })),
@@ -358,13 +366,13 @@ export var schema;
             .datetime()
             .check(z.describe('When the subscription was last changed, as an ISO 8601 timestamp.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })),
     })
-        .check(z.describe('A webhook subscription that tells Tempo which onchain events to send to your destination.'));
+        .check(z.describe('A webhook subscription that tells Tempo which onchain events to send to its destination.')), 'Webhook');
     /** Outcome of a single delivery attempt. */
     schema.DeliveryStatus = z
         .enum(['failed', 'pending', 'succeeded'])
         .check(z.describe('Outcome of a webhook delivery attempt.'), z.meta({ examples: ['succeeded'] }));
     /** A logged delivery attempt for a subscription. */
-    schema.Delivery = z
+    schema.Delivery = OpenApi.component(z
         .object({
         attempt: z
             .number()
@@ -382,7 +390,7 @@ export var schema;
             .string()
             .check(z.describe('Webhook delivery ID (`whd_…`).'), z.meta({ examples: ['whd_001718668800000_C1yJkk7CuML98HFthEDk9PsY'] })),
         requestUrl: z
-            .string()
+            .url()
             .check(z.describe('Your callback URL that Tempo attempted to deliver to.'), z.meta({ examples: ['https://example.com/webhooks'] })),
         responseMs: z
             .optional(z.number().check(z.int(), z.nonnegative()))
@@ -395,14 +403,14 @@ export var schema;
             .string()
             .check(z.describe('Subscription ID (`wh_…`) this delivery belongs to.'), z.meta({ examples: ['wh_001718668800000_2ZPE2gvateYEQ0dQslgvkhjx'] })),
     })
-        .check(z.describe('One attempt by Tempo to deliver an event to your webhook URL.'));
+        .check(z.describe('One attempt by Tempo to deliver an event to a webhook destination.')), 'WebhookDelivery');
     /**
      * A `transfer` event payload: the decoded TIP-20 `Transfer` row. Mirrors a
      * `GET /transfers` row but without the `sourceToken` metadata enrichment the
      * read endpoint adds (webhook delivery does not perform per-event token
      * lookups).
      */
-    schema.TransferEvent = z
+    schema.TransferEvent = OpenApi.component(z
         .object({
         address: Schema.TokenAddress.check(z.describe('TIP-20 token contract address.'), z.meta({ examples: ['0x20c0000000000000000000008f5425160ebe5525'] })),
         amount: z
@@ -430,12 +438,12 @@ export var schema;
             examples: ['0x3d24a706cc2f6f4c96620bef1f61ddb23040ff77c22c8db42918c7c424bbf9d3'],
         })),
     })
-        .check(z.describe('Payload for a `token:transfer` event, decoded from a TIP-20 `Transfer` log.'));
+        .check(z.describe('Payload for a `token:transfer` event, decoded from a TIP-20 `Transfer` log.')), 'WebhookTransferEvent');
     /**
      * A `transaction` event payload using the humanized transaction shape without
      * opt-in read resources such as receipts.
      */
-    schema.TransactionEvent = z
+    schema.TransactionEvent = OpenApi.component(z
         .object({
         ...Transactions.schema.Transaction.shape,
         meta: z
@@ -444,14 +452,14 @@ export var schema;
         })
             .check(z.describe('Metadata for this transaction webhook event.')),
     })
-        .check(z.describe('A transaction included in a block.'));
+        .check(z.describe('A transaction included in a block.')), 'WebhookTransactionEvent');
     /**
      * A `log:emitted` event payload: the raw contract event log. When a
      * `signature` filter was supplied and decoding succeeds, the best-effort
      * `event`/`args` fields carry the decoded event name and arguments (large
      * integers as decimal strings).
      */
-    schema.LogEvent = z
+    schema.LogEvent = OpenApi.component(z
         .object({
         address: Schema.Address.check(z.describe('Contract that emitted the log.'), z.meta({ examples: ['0x20c00000000000000000000071de0cd31ab0d105'] })),
         args: z.optional(z
@@ -484,8 +492,9 @@ export var schema;
         timestamp: z.iso
             .datetime()
             .check(z.describe('When the block was produced, as an ISO 8601 timestamp.'), z.meta({ examples: ['2026-01-14T18:38:03.685Z'] })),
-        topics: z.array(Schema.Hash).check(z.describe('Log topics, starting with the event signature hash (topic 0).'), z.meta({
+        topics: z.array(Schema.Hash).check(z.describe('Zero to four log topics; non-anonymous events start with the event signature hash.'), z.meta({
             examples: [
+                [],
                 [
                     '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
                     '0x000000000000000000000000e7687128b0a808c2831ff94d4f7b2fb35c65af38',
@@ -499,9 +508,9 @@ export var schema;
             .number()
             .check(z.int(), z.nonnegative(), z.describe('Index of the transaction within its block.'), z.meta({ examples: [0] })),
     })
-        .check(z.describe('Payload for a `log:emitted` event (a raw contract event log).'));
+        .check(z.describe('Payload for a `log:emitted` event (a raw contract event log).')), 'WebhookLogEvent');
     /** Payload for a `block:created` event (an RPC-derived block header). */
-    schema.BlockEvent = z
+    schema.BlockEvent = OpenApi.component(z
         .object({
         number: z
             .number()
@@ -527,21 +536,25 @@ export var schema;
             .datetime()
             .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;
-    /** Public funding transfer after a committed material change. */
-    schema.FundingTransferEvent = FundingTransfer.schema.FundingTransfer;
+        .check(z.describe('Payload for a `block:created` event (a new block header).')), 'WebhookBlockEvent');
+    /** Public route deposit after a committed material change. */
+    schema.RoutesDepositEvent = RoutesDeposit.schema.RoutesDeposit;
+    /** Public route transfer after a committed material change. */
+    schema.RoutesTransferEvent = RoutesTransfer.schema.RoutesTransfer;
     /** A `ping` (synthetic test-delivery) payload, sent by `POST /webhooks/:id/ping`. */
-    schema.PingEvent = z
+    schema.PingEvent = OpenApi.component(z
         .object({
-        ping: z.literal(true).check(z.describe('Marks this payload as a synthetic ping test.')),
+        ping: z
+            .literal(true)
+            .check(z.describe('Marks this payload as a synthetic ping test.'), z.meta({ examples: [true] })),
     })
-        .check(z.describe('Payload for a webhook ping test delivery.'));
+        .check(z.describe('Payload for a webhook ping test delivery.')), 'WebhookPingEvent');
     /** Fields common to every delivery envelope. */
     const envelopeBase = {
         chainId: Schema.ChainId,
-        context: z.optional(schema.Context),
+        context: z
+            .optional(schema.Context)
+            .check(z.meta({ examples: [{ title: 'Prod USDC large transfers' }] })),
         createdAt: z.iso
             .datetime()
             .check(z.describe('When Tempo built this delivery envelope, as an ISO 8601 timestamp.'), z.meta({ examples: ['2026-01-14T18:38:03.000Z'] })),
@@ -561,139 +574,176 @@ export var schema;
      * variant selector — without per-variant titles, inline `oneOf` members render
      * as a single (first) collapsed schema.
      */
-    schema.Envelope = z
+    schema.Envelope = OpenApi.component(z
         .discriminatedUnion('type', [
         z
-            .object({ ...envelopeBase, data: schema.TransferEvent, type: z.literal('token:transfer') })
+            .object({
+            ...envelopeBase,
+            data: schema.TransferEvent,
+            type: z.literal('token:transfer').check(z.meta({ examples: ['token:transfer'] })),
+        })
             .check(z.meta({ title: 'Transfer event' })),
         z
             .object({
             ...envelopeBase,
             data: schema.TransactionEvent,
-            type: z.literal('transaction:included'),
+            type: z
+                .literal('transaction:included')
+                .check(z.meta({ examples: ['transaction:included'] })),
         })
             .check(z.meta({ title: 'Included transaction event' })),
         z
-            .object({ ...envelopeBase, data: schema.LogEvent, type: z.literal('log:emitted') })
+            .object({
+            ...envelopeBase,
+            data: schema.LogEvent,
+            type: z.literal('log:emitted').check(z.meta({ examples: ['log:emitted'] })),
+        })
             .check(z.meta({ title: 'Log event' })),
         z
-            .object({ ...envelopeBase, data: schema.BlockEvent, type: z.literal('block:created') })
+            .object({
+            ...envelopeBase,
+            data: schema.BlockEvent,
+            type: z.literal('block:created').check(z.meta({ examples: ['block:created'] })),
+        })
             .check(z.meta({ title: 'Block event' })),
         z
             .object({
             ...envelopeBase,
-            data: schema.FundingDepositEvent,
-            type: z.literal('funding:deposit.updated'),
+            data: schema.RoutesDepositEvent,
+            type: z
+                .literal('routes:deposit.updated')
+                .check(z.meta({ examples: ['routes:deposit.updated'] })),
         })
-            .check(z.meta({ title: 'Funding deposit updated event' })),
+            .check(z.meta({ title: 'Route deposit updated event' })),
         z
             .object({
             ...envelopeBase,
-            data: schema.FundingTransferEvent,
-            type: z.literal('funding:transfer.updated'),
+            data: schema.RoutesTransferEvent,
+            type: z
+                .literal('routes:transfer.updated')
+                .check(z.meta({ examples: ['routes:transfer.updated'] })),
         })
-            .check(z.meta({ title: 'Funding transfer updated event' })),
+            .check(z.meta({ title: 'Route transfer updated event' })),
         z
-            .object({ ...envelopeBase, data: schema.PingEvent, type: z.literal('ping') })
+            .object({
+            ...envelopeBase,
+            data: schema.PingEvent,
+            type: z.literal('ping').check(z.meta({ examples: ['ping'] })),
+        })
             .check(z.meta({ title: 'Ping (test delivery)' })),
     ])
-        .check(z.describe('The signed JSON payload Tempo POSTs to your webhook URL.'));
+        .check(z.describe('The signed JSON payload Tempo POSTs to a webhook destination.')), 'WebhookEventEnvelope');
     /** Schemas for the getWebhookEventTypes operation. */
     let getWebhookEventTypes;
     (function (getWebhookEventTypes) {
-        getWebhookEventTypes.Response = z
+        const EventTypeEntry = OpenApi.component(z
             .object({
-            data: z
-                .array(z.object({
-                description: z
-                    .string()
-                    .check(z.describe('Plain-English description of the event type.'), z.meta({ examples: ['TIP-20 token transfer event.'] })),
-                type: schema.EventType.check(z.meta({ examples: ['token:transfer'] })),
-            }))
-                .check(z.describe('Webhook event types available for subscription.')),
+            description: z
+                .string()
+                .check(z.describe('Plain-English description of the event type.'), z.meta({ examples: ['TIP-20 token transfer event.'] })),
+            type: schema.EventType.check(z.meta({ examples: ['token:transfer'] })),
         })
-            .check(z.describe('List of webhook event types Tempo can send.'));
+            .check(z.describe('One webhook event type available for subscription.')), 'WebhookEventType');
+        getWebhookEventTypes.Response = OpenApi.component(z
+            .object({
+            data: z.array(EventTypeEntry).check(z.describe('Webhook event types available for subscription.'), z.meta({
+                examples: [[{ description: 'TIP-20 token transfer event.', type: 'token:transfer' }]],
+            })),
+        })
+            .check(z.describe('List of webhook event types Tempo can send.')), 'WebhookEventTypeList');
     })(getWebhookEventTypes = schema.getWebhookEventTypes || (schema.getWebhookEventTypes = {}));
     /** Schemas for the createWebhook operation. */
     let createWebhook;
     (function (createWebhook) {
+        /** Request variant for TIP-20 transfer subscriptions. */
+        createWebhook.TransferBody = OpenApi.component(z
+            .object({
+            chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
+            context: z.optional(schema.Context),
+            destination: Destination,
+            eventType: z
+                .literal('token:transfer')
+                .check(z.describe('Event type you want Tempo to send to your webhook URL.'), z.meta({ examples: ['token:transfer'] })),
+            filters: z.optional(schema.TransferFilters),
+        })
+            .check(z.meta({ title: 'Transfer subscription' })), 'CreateWebhookTransferRequest');
+        /** Request variant for included transaction subscriptions. */
+        createWebhook.TransactionBody = OpenApi.component(z
+            .object({
+            chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
+            context: z.optional(schema.Context),
+            destination: Destination,
+            eventType: z
+                .literal('transaction:included')
+                .check(z.describe('Event type you want Tempo to send to your webhook URL.'), z.meta({ examples: ['transaction:included'] })),
+            filters: z.optional(schema.TxFilters),
+        })
+            .check(z.meta({ title: 'Included-transaction subscription' })), 'CreateWebhookTransactionRequest');
+        /** Request variant for emitted log subscriptions. */
+        createWebhook.LogBody = OpenApi.component(z
+            .object({
+            chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
+            context: z.optional(schema.Context),
+            destination: Destination,
+            eventType: z
+                .literal('log:emitted')
+                .check(z.describe('Event type you want Tempo to send to your webhook URL.'), z.meta({ examples: ['log:emitted'] })),
+            filters: schema.LogFilters,
+        })
+            .check(z.meta({ title: 'Log subscription' })), 'CreateWebhookLogRequest');
+        /** Request variant for created block subscriptions. */
+        createWebhook.BlockBody = OpenApi.component(z
+            .object({
+            chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
+            context: z.optional(schema.Context),
+            destination: Destination,
+            eventType: z
+                .literal('block:created')
+                .check(z.describe('Event type you want Tempo to send to your webhook URL.'), z.meta({ examples: ['block:created'] })),
+            filters: z.optional(schema.BlockFilters),
+        })
+            .check(z.meta({ title: 'Block subscription' })), 'CreateWebhookBlockRequest');
+        /** Request variant for route deposit subscriptions. */
+        createWebhook.RoutesDepositBody = OpenApi.component(z
+            .object({
+            chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
+            context: z.optional(schema.Context),
+            destination: Destination,
+            eventType: z
+                .literal('routes:deposit.updated')
+                .check(z.describe('Event type for committed route deposit changes.'), z.meta({ examples: ['routes:deposit.updated'] })),
+            filters: z.optional(schema.RoutesDepositFilters),
+        })
+            .check(z.meta({ title: 'Route deposit subscription' })), 'CreateWebhookRoutesDepositRequest');
+        /** Request variant for route transfer subscriptions. */
+        createWebhook.RoutesTransferBody = OpenApi.component(z
+            .object({
+            chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
+            context: z.optional(schema.Context),
+            destination: Destination,
+            eventType: z
+                .literal('routes:transfer.updated')
+                .check(z.describe('Event type for committed route transfer changes.'), z.meta({ examples: ['routes:transfer.updated'] })),
+            filters: z.optional(schema.RoutesTransferFilters),
+        })
+            .check(z.meta({ title: 'Route transfer subscription' })), 'CreateWebhookRoutesTransferRequest');
         /**
          * Discriminated on `eventType` so each variant carries its own typed
          * `filters` object — this is what lets the docs render the valid filter
          * fields per event type instead of an opaque map. Variant `title`s drive the
          * doc renderer's selector (see {@link schema.Envelope}).
          */
-        createWebhook.Body = z
+        createWebhook.Body = OpenApi.component(z
             .discriminatedUnion('eventType', [
-            z
-                .object({
-                chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
-                context: z.optional(schema.Context),
-                destination: Destination,
-                eventType: z
-                    .literal('token:transfer')
-                    .check(z.describe('Event type you want Tempo to send to your webhook URL.'), z.meta({ examples: ['token:transfer'] })),
-                filters: z.optional(schema.TransferFilters),
-            })
-                .check(z.meta({ title: 'Transfer subscription' })),
-            z
-                .object({
-                chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
-                context: z.optional(schema.Context),
-                destination: Destination,
-                eventType: z
-                    .literal('transaction:included')
-                    .check(z.describe('Event type you want Tempo to send to your webhook URL.'), z.meta({ examples: ['transaction:included'] })),
-                filters: z.optional(schema.TxFilters),
-            })
-                .check(z.meta({ title: 'Included-transaction subscription' })),
-            z
-                .object({
-                chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
-                context: z.optional(schema.Context),
-                destination: Destination,
-                eventType: z
-                    .literal('log:emitted')
-                    .check(z.describe('Event type you want Tempo to send to your webhook URL.'), z.meta({ examples: ['log:emitted'] })),
-                filters: schema.LogFilters,
-            })
-                .check(z.meta({ title: 'Log subscription' })),
-            z
-                .object({
-                chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
-                context: z.optional(schema.Context),
-                destination: Destination,
-                eventType: z
-                    .literal('block:created')
-                    .check(z.describe('Event type you want Tempo to send to your webhook URL.'), z.meta({ examples: ['block:created'] })),
-                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' })),
-            z
-                .object({
-                chainId: z.optional(Schema.ChainId).check(z.meta({ examples: [4217] })),
-                context: z.optional(schema.Context),
-                destination: Destination,
-                eventType: z
-                    .literal('funding:transfer.updated')
-                    .check(z.describe('Event type for committed funding transfer changes.'), z.meta({ examples: ['funding:transfer.updated'] })),
-                filters: z.optional(schema.FundingTransferFilters),
-            })
-                .check(z.meta({ title: 'Funding transfer subscription' })),
+            createWebhook.TransferBody,
+            createWebhook.TransactionBody,
+            createWebhook.LogBody,
+            createWebhook.BlockBody,
+            createWebhook.RoutesDepositBody,
+            createWebhook.RoutesTransferBody,
         ])
-            .check(z.describe('Details for creating a webhook subscription.'));
-        createWebhook.Response = z
+            .check(z.describe('Details for creating a webhook subscription.')), 'CreateWebhookRequest');
+        createWebhook.Response = OpenApi.component(z
             .object({
             ...schema.Subscription.shape,
             destination: Destination,
@@ -701,7 +751,7 @@ export var schema;
                 .string()
                 .check(z.describe('HMAC signing secret (`whsec_…`) used to verify Tempo webhook signatures. It is shown once when you create the webhook, so store it now.'), z.meta({ examples: ['whsec_abc123'] })),
         })
-            .check(z.describe('The new webhook subscription, including the one-time signing secret.'));
+            .check(z.describe('The new webhook subscription, including the one-time signing secret.')), 'CreateWebhookResponse');
     })(createWebhook = schema.createWebhook || (schema.createWebhook = {}));
     /** Schemas for the listWebhooks operation. */
     let listWebhooks;
@@ -714,15 +764,17 @@ export var schema;
             page: Schema.Page,
         })
             .check(...Schema.pageChecks(), z.describe('Query parameters for listing your webhook subscriptions.'));
-        listWebhooks.Response = z
+        listWebhooks.Response = OpenApi.component(z
             .object({
-            data: z.array(schema.Subscription).check(z.describe('Webhook subscriptions on this page.')),
+            data: z
+                .array(schema.Subscription)
+                .check(z.describe('Webhook subscriptions on this page.'), z.meta({ examples: [[]] })),
             meta: z
                 .optional(Schema.CountMeta)
-                .check(z.describe('Extra response metadata requested with `include`.')),
+                .check(z.describe('Extra response metadata requested with `include`.'), z.meta({ examples: [{ totalCount: 1, totalCountCapped: false }] })),
             nextCursor: Schema.NextCursor,
         })
-            .check(z.describe('A page of your webhook subscriptions.'));
+            .check(z.describe('A page of webhook subscriptions.')), 'WebhookList');
     })(listWebhooks = schema.listWebhooks || (schema.listWebhooks = {}));
     /** Schemas for the getWebhook operation. */
     let getWebhook;
@@ -748,21 +800,23 @@ export var schema;
             page: Schema.Page,
         })
             .check(...Schema.pageChecks(), z.describe('Query parameters for listing webhook delivery attempts.'));
-        listWebhookDeliveries.Response = z
+        listWebhookDeliveries.Response = OpenApi.component(z
             .object({
-            data: z.array(schema.Delivery).check(z.describe('Webhook delivery attempts on this page.')),
+            data: z
+                .array(schema.Delivery)
+                .check(z.describe('Webhook delivery attempts on this page.'), z.meta({ examples: [[]] })),
             meta: z
                 .optional(Schema.CountMeta)
-                .check(z.describe('Extra response metadata requested with `include`.')),
+                .check(z.describe('Extra response metadata requested with `include`.'), z.meta({ examples: [{ totalCount: 1, totalCountCapped: false }] })),
             nextCursor: Schema.NextCursor,
         })
-            .check(z.describe('A page of webhook delivery attempts.'));
+            .check(z.describe('A page of webhook delivery attempts.')), 'WebhookDeliveryList');
     })(listWebhookDeliveries = schema.listWebhookDeliveries || (schema.listWebhookDeliveries = {}));
     /** Schemas for the pingWebhook operation. */
     let pingWebhook;
     (function (pingWebhook) {
         pingWebhook.Params = getWebhook.Params;
-        pingWebhook.Response = z
+        pingWebhook.Response = OpenApi.component(z
             .object({
             delivered: z
                 .boolean()
@@ -780,7 +834,7 @@ export var schema;
                 .optional(z.number().check(z.int()))
                 .check(z.describe('HTTP status your endpoint returned, when Tempo received a response.'), z.meta({ examples: [200] })),
         })
-            .check(z.describe('Result of sending a synthetic ping event to your webhook URL.'));
+            .check(z.describe('Result of sending a synthetic ping event to a webhook destination.')), 'PingWebhookResponse');
     })(pingWebhook = schema.pingWebhook || (schema.pingWebhook = {}));
     /** Schemas for the retryWebhookDelivery operation. */
     let retryWebhookDelivery;
@@ -795,13 +849,13 @@ export var schema;
                 .check(z.describe('Webhook subscription ID (`wh_…`).'), z.meta({ examples: ['wh_001718668800000_2ZPE2gvateYEQ0dQslgvkhjx'] })),
         })
             .check(z.describe('Path parameters for retrying a webhook delivery.'));
-        retryWebhookDelivery.Response = pingWebhook.Response;
+        retryWebhookDelivery.Response = OpenApi.component(pingWebhook.Response, 'RetryWebhookDeliveryResponse');
     })(retryWebhookDelivery = schema.retryWebhookDelivery || (schema.retryWebhookDelivery = {}));
     /** Schemas for the updateWebhook operation. */
     let updateWebhook;
     (function (updateWebhook) {
         updateWebhook.Params = getWebhook.Params;
-        updateWebhook.Body = z
+        updateWebhook.Body = OpenApi.component(z
             .object({
             context: z
                 .optional(z.nullable(schema.Context))
@@ -816,20 +870,20 @@ export var schema;
                 .optional(schema.Status)
                 .check(z.describe('New lifecycle status, such as pausing or resuming delivery.')),
         })
-            .check(z.describe('Fields you want to update on the webhook subscription.'));
+            .check(z.describe('Fields to update on the webhook subscription.')), 'UpdateWebhookRequest');
         updateWebhook.Response = schema.Subscription;
     })(updateWebhook = schema.updateWebhook || (schema.updateWebhook = {}));
     /** Schemas for the deleteWebhook operation. */
     let deleteWebhook;
     (function (deleteWebhook) {
         deleteWebhook.Params = getWebhook.Params;
-        deleteWebhook.Response = z
+        deleteWebhook.Response = OpenApi.component(z
             .object({
             id: z
                 .string()
                 .check(z.describe('ID of the webhook subscription that was deleted.'), z.meta({ examples: ['wh_001718668800000_2ZPE2gvateYEQ0dQslgvkhjx'] })),
         })
-            .check(z.describe('Confirmation that the webhook subscription was deleted.'));
+            .check(z.describe('Confirmation that the webhook subscription was deleted.')), 'DeleteWebhookResponse');
     })(deleteWebhook = schema.deleteWebhook || (schema.deleteWebhook = {}));
 })(schema || (schema = {}));
 /**
@@ -841,8 +895,7 @@ export var schema;
  */
 export function webhooks(options = {}) {
     const hidden = !options.enabled;
-    const availableEventTypes = eventTypeDescriptions.filter((eventType) => !isFundingEventType(eventType.type) ||
-        options.applicationEventTypes?.includes(eventType.type));
+    const availableEventTypes = eventTypeDescriptions.filter((eventType) => !isRoutesEventType(eventType.type) || 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).
@@ -865,6 +918,16 @@ export function webhooks(options = {}) {
         hide: hidden,
         operationId: 'getWebhookEventTypes',
         responses: OpenApi.responses({
+            errors: {
+                400: {
+                    codes: [],
+                    description: 'The API key credential is malformed.',
+                },
+                404: {
+                    codes: ['webhooks_not_enabled'],
+                    description: 'Webhooks are not enabled for this API deployment.',
+                },
+            },
             success: {
                 description: 'Webhook event types available for subscription.',
                 schema: schema.getWebhookEventTypes.Response,
@@ -910,7 +973,11 @@ export function webhooks(options = {}) {
                 },
                 403: {
                     codes: ['api_key_forbidden', 'limit_exceeded'],
-                    description: 'The API key lacks access or the subscription limit was reached.',
+                    description: 'The API key lacks access or its creator-shared subscription limit was reached.',
+                },
+                404: {
+                    codes: ['webhooks_not_enabled'],
+                    description: 'Webhooks are not enabled for this API deployment.',
                 },
             },
             success: {
@@ -943,10 +1010,10 @@ export function webhooks(options = {}) {
                 message: 'Webhook event type is not available in this deployment',
                 status: 400,
             });
-        if (isFundingEventType(body.eventType)) {
+        if (isRoutesEventType(body.eventType)) {
             if (principal?.type !== 'api_key')
                 return unauthorized(c);
-            if (!principal.apiKey.scopes.some((scope) => scope === Scope.wildcard || scope === 'funding:read'))
+            if (!principal.apiKey.scopes.some((scope) => scope === Scope.wildcard || scope === 'routes:read'))
                 return Response.error(c, {
                     code: 'api_key_forbidden',
                     message: 'API key missing required scope',
@@ -961,9 +1028,9 @@ export function webhooks(options = {}) {
             // Preserve destination errors before the creation-time RPC dependency.
             WebhookDestination.assertDestination(body.destination);
             const maxPerOwner = webhook.maxPerOwner ?? defaultMaxPerOwner;
-            if ((await Webhooks.countSubscriptions(db, owner)) >= maxPerOwner)
+            if ((await Webhooks.countSubscriptionsForLimit(db, { owner })) >= maxPerOwner)
                 throw new Webhooks.LimitExceededError(maxPerOwner);
-            const startBlockNumber = isFundingEventType(body.eventType)
+            const startBlockNumber = isRoutesEventType(body.eventType)
                 ? undefined
                 : await getRpcHead(c.get('getClient')(chainId));
             const subscription = await Webhooks.createSubscription(db, {
@@ -1000,6 +1067,16 @@ export function webhooks(options = {}) {
         hide: hidden,
         operationId: 'listWebhooks',
         responses: OpenApi.responses({
+            errors: {
+                400: {
+                    codes: ['query_invalid'],
+                    description: 'The query parameters are invalid.',
+                },
+                404: {
+                    codes: ['webhooks_not_enabled'],
+                    description: 'Webhooks are not enabled for this API deployment.',
+                },
+            },
             success: {
                 description: 'A page of webhook subscriptions.',
                 schema: schema.listWebhooks.Response,
@@ -1067,9 +1144,13 @@ export function webhooks(options = {}) {
         operationId: 'getWebhook',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['param_invalid'],
+                    description: 'The webhook ID is invalid.',
+                },
                 404: {
                     description: 'No webhook subscription was found for that ID.',
-                    codes: ['webhook_not_found'],
+                    codes: ['webhook_not_found', 'webhooks_not_enabled'],
                 },
             },
             success: {
@@ -1117,9 +1198,13 @@ export function webhooks(options = {}) {
         operationId: 'listWebhookDeliveries',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['param_invalid', 'query_invalid'],
+                    description: 'The webhook ID or query parameters are invalid.',
+                },
                 404: {
                     description: 'No webhook subscription was found for that ID.',
-                    codes: ['webhook_not_found'],
+                    codes: ['webhook_not_found', 'webhooks_not_enabled'],
                 },
             },
             success: {
@@ -1195,9 +1280,13 @@ export function webhooks(options = {}) {
         operationId: 'pingWebhook',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['param_invalid'],
+                    description: 'The webhook ID is invalid.',
+                },
                 404: {
                     description: 'No webhook subscription was found for that ID.',
-                    codes: ['webhook_not_found'],
+                    codes: ['webhook_not_found', 'webhooks_not_enabled'],
                 },
             },
             success: {
@@ -1253,9 +1342,13 @@ export function webhooks(options = {}) {
         operationId: 'retryWebhookDelivery',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['param_invalid'],
+                    description: 'The webhook or delivery ID is invalid.',
+                },
                 404: {
                     description: 'No webhook subscription or delivery was found for those IDs.',
-                    codes: ['webhook_not_found', 'delivery_not_found'],
+                    codes: ['webhook_not_found', 'delivery_not_found', 'webhooks_not_enabled'],
                 },
             },
             success: {
@@ -1332,7 +1425,7 @@ export function webhooks(options = {}) {
                 },
                 404: {
                     description: 'No webhook subscription was found for that ID.',
-                    codes: ['webhook_not_found'],
+                    codes: ['webhook_not_found', 'webhooks_not_enabled'],
                 },
             },
             success: {
@@ -1394,9 +1487,13 @@ export function webhooks(options = {}) {
         operationId: 'deleteWebhook',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['param_invalid'],
+                    description: 'The webhook ID is invalid.',
+                },
                 404: {
                     description: 'No webhook subscription was found for that ID.',
-                    codes: ['webhook_not_found'],
+                    codes: ['webhook_not_found', 'webhooks_not_enabled'],
                 },
             },
             success: {
@@ -1521,8 +1618,8 @@ export async function getRpcHead(client) {
 }
 const filterSchemas = {
     'block:created': schema.BlockFilters,
-    'funding:deposit.updated': schema.FundingDepositFilters,
-    'funding:transfer.updated': schema.FundingTransferFilters,
+    'routes:deposit.updated': schema.RoutesDepositFilters,
+    'routes:transfer.updated': schema.RoutesTransferFilters,
     'log:emitted': schema.LogFilters,
     'token:transfer': schema.TransferFilters,
     'transaction:included': schema.TxFilters,
@@ -1574,7 +1671,7 @@ const toBig = (value) => BigInt(String(value));
 function operandEquals(value, target, kind) {
     return kind === 'number'
         ? toBig(value) === toBig(target)
-        : value.toLowerCase() === String(target).toLowerCase();
+        : String(value).toLowerCase() === String(target).toLowerCase();
 }
 /**
  * The JS counterpart of the old SQL `applyOperator`: evaluates one parsed filter
@@ -1596,10 +1693,11 @@ export function matchesOperator(value, op, kind = 'string') {
     if (typeof op !== 'object' || op === null)
         return operandEquals(value, op, kind);
     const o = op;
+    const value_string = String(value);
     if ('selector' in o)
-        return value.slice(0, 10).toLowerCase() === String(o['selector']).toLowerCase();
+        return value_string.slice(0, 10).toLowerCase() === String(o['selector']).toLowerCase();
     if ('startsWith' in o)
-        return value.toLowerCase().startsWith(String(o['startsWith']).toLowerCase());
+        return value_string.toLowerCase().startsWith(String(o['startsWith']).toLowerCase());
     if ('in' in o)
         return o['in'].some((v) => operandEquals(value, v, kind));
     if ('not' in o)
@@ -1650,12 +1748,11 @@ function toLogEvent(log, timestamp, signature, event) {
     const blockNumber = log.blockNumber === null ? undefined : Number(log.blockNumber);
     const logIndex = log.logIndex ?? undefined;
     const transactionIndex = log.transactionIndex ?? undefined;
-    const topics = log.topics.filter((t) => typeof t === 'string');
-    const topic0 = Schema.Hash.safeParse(topics[0]);
+    const topics = z.array(Schema.Hash).safeParse(log.topics);
     const data = typeof log.data === 'string' ? log.data : '0x';
     if (!address.success ||
         !transactionHash.success ||
-        !topic0.success ||
+        !topics.success ||
         blockNumber === undefined ||
         logIndex === undefined ||
         transactionIndex === undefined ||
@@ -1667,16 +1764,19 @@ function toLogEvent(log, timestamp, signature, event) {
         data,
         logIndex,
         timestamp,
-        topics,
+        topics: topics.data,
         transactionHash: transactionHash.data,
         transactionIndex,
     };
     if (!signature || !event || log.args === undefined)
         return base;
+    const topic0 = topics.data[0];
+    if (!topic0)
+        return undefined;
     return {
         ...base,
         args: serializeArgs(log.args),
-        event: { name: event.name, signature, topic0: topic0.data },
+        event: { name: event.name, signature, topic0 },
     };
 }
 /** Narrows an exact or membership operator into an RPC filter value. */
@@ -1823,7 +1923,10 @@ function matchesLog(log, f, event) {
             const numeric = /^u?int/.test(input.type);
             const value = args[name];
             const normalized = input.type === 'address' ? lowercaseLeaves(op) : op;
-            if (!matchesOperator(asString(value), normalized, numeric ? 'number' : 'string'))
+            const operand = typeof value === 'bigint' || typeof value === 'number' || typeof value === 'string'
+                ? value
+                : undefined;
+            if (!matchesOperator(operand, normalized, numeric ? 'number' : 'string'))
                 return false;
         }
     }
@@ -1963,7 +2066,7 @@ function toPublic(subscription) {
         ...(subscription.context === undefined ? {} : { context: subscription.context }),
         createdAt: subscription.createdAt,
         destination: redactDestination(subscription.destination),
-        ...(isFundingEventType(subscription.eventType) && subscription.environment !== undefined
+        ...(isRoutesEventType(subscription.eventType) && subscription.environment !== undefined
             ? { environment: subscription.environment }
             : {}),
         eventType: subscription.eventType,