tapimo 0.5.0 → 0.5.2

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

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-import { parseAbiItem } from 'viem';
+import { decodeEventLog, encodeEventTopics, parseAbiItem } from 'viem';
 import * as z from 'zod/mini';
 import * as Auth from '../../../internal/Auth.js';
 import * as Cache from '../../../internal/Cache.js';
@@ -23,6 +23,8 @@ const defaultMaxPerOwner = 100;
  * paid-once / deliver-forever mismatch. API-key-owned subscriptions have no TTL.
  */
 const mppTtlMs = 30 * 24 * 60 * 60 * 1_000;
+const redactedBetterstackToken = '[redacted]';
+const redactedSlackUrl = 'https://hooks.slack.com/…';
 /**
  * The subscribable webhook event types, in alphabetical order. The source of
  * truth for the event-type *set*: the {@link EventType} union and the route zod
@@ -69,15 +71,13 @@ export var schema;
     const Url = z
         .url()
         .check(z.describe('Your HTTPS endpoint where Tempo sends signed event POSTs.'), z.meta({ examples: ['https://example.com/webhooks'] }));
-    const SlackUrl = z
-        .url()
-        .check(z.describe('Your Slack incoming-webhook URL (`https://hooks.slack.com/services/…`).'), z.meta({ examples: ['https://hooks.slack.com/services/T000/B000/XXXXXXXX'] }));
+    const SlackUrl = z.url().check(z.refine((url) => url !== redactedSlackUrl, { error: 'A Slack webhook URL is required.' }), z.describe('Your Slack incoming-webhook URL (`https://hooks.slack.com/services/…`).'), z.meta({ examples: ['https://hooks.slack.com/services/T000/B000/XXXXXXXX'] }));
     const BetterstackUrl = z
         .url()
         .check(z.describe('Your Better Stack source ingest host URL (`https://<host>.betterstackdata.com`).'), z.meta({ examples: ['https://s1234567.eu-nbg-2.betterstackdata.com'] }));
-    const BetterstackToken = z
-        .string()
-        .check(z.minLength(1), z.describe('Your Better Stack source token (sent as `Authorization: Bearer …`).'), z.meta({ examples: ['FczKcxEhjEDE58dBX7XaeX1q'] }));
+    const BetterstackToken = z.string().check(z.minLength(1), z.refine((token) => token !== redactedBetterstackToken, {
+        error: 'A Better Stack source token is required.',
+    }), z.describe('Your Better Stack source token (sent as `Authorization: Bearer …`).'), z.meta({ examples: ['FczKcxEhjEDE58dBX7XaeX1q'] }));
     /**
      * Where matched events are delivered: a `url` destination (a signed event POST
      * to your HTTPS endpoint), a `slack` destination (a formatted message posted to
@@ -101,6 +101,25 @@ export var schema;
         }),
     ])
         .check(z.describe('Delivery destination: an HTTPS URL, a Slack incoming-webhook URL, or a Better Stack source.'));
+    const PublicDestination = z
+        .discriminatedUnion('type', [
+        z.object({
+            type: z.literal('url'),
+            url: Url,
+        }),
+        z.object({
+            type: z.literal('slack'),
+            url: z.literal(redactedSlackUrl).check(z.describe('Redacted Slack webhook URL.')),
+        }),
+        z.object({
+            token: z
+                .literal(redactedBetterstackToken)
+                .check(z.describe('Redacted Better Stack source token.')),
+            type: z.literal('betterstack'),
+            url: BetterstackUrl,
+        }),
+    ])
+        .check(z.describe('Delivery destination with bearer credentials redacted.'));
     /**
      * Equality / membership operator for a filterable field. A consumer can pass a
      * bare value (shorthand for exact equality, the common case) or an operator
@@ -238,9 +257,8 @@ export var schema;
         error: 'Pass `signature` or `topic0`, not both.',
     }), z.refine((f) => !f.args || f.signature, {
         error: '`args` requires `signature` to decode the event.',
-    }), z.refine((f) => Boolean(f.address) ||
-        (Boolean(f.signature || f.topic0) && Boolean(f.topic1 || f.topic2 || f.topic3 || f.args)), {
-        error: 'Addressless log filters must include an event signature or topic0 plus at least one indexed topic or argument.',
+    }), 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.',
     }));
     /**
      * `block:created` subscription filters. All optional and AND-combined; unlike
@@ -289,7 +307,7 @@ export var schema;
         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'] })),
-        destination: Destination,
+        destination: PublicDestination,
         eventType: schema.EventType.check(z.meta({ examples: ['token:transfer'] })),
         expiresAt: z
             .optional(z.iso.datetime())
@@ -596,7 +614,9 @@ export var schema;
         ])
             .check(z.describe('Details for creating a webhook subscription.'));
         createWebhook.Response = z
-            .extend(schema.Subscription, {
+            .object({
+            ...schema.Subscription.shape,
+            destination: Destination,
             secret: z
                 .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'] })),
@@ -1586,6 +1606,8 @@ export function matchesOperator(value, op, kind = 'string') {
         return o['in'].some((v) => operandEquals(value, v, kind));
     if ('not' in o)
         return !operandEquals(value, o['not'], kind);
+    if ('eq' in o && kind === 'string')
+        return operandEquals(value, o['eq'], kind);
     // Comparison object: AND-combine whichever of eq/gt/gte/lt/lte are present.
     const n = toBig(value);
     let ok = true;
@@ -1739,33 +1761,124 @@ function toLogEvent(log, timestamp, signature, event) {
         event: { name: event.name, signature, topic0: topic0.data },
     };
 }
+/** Narrows an exact or membership operator into an RPC filter value. */
+function pushValue(op) {
+    const value = (() => {
+        if (typeof op !== 'object' || op === null)
+            return op;
+        const operator = op;
+        if ('eq' in operator)
+            return operator['eq'];
+        if (Array.isArray(operator['in']) && operator['in'].length > 0)
+            return operator['in'];
+        return undefined;
+    })();
+    const scalar = (item) => ['bigint', 'boolean', 'number', 'string'].includes(typeof item);
+    if (scalar(value))
+        return value;
+    if (Array.isArray(value) && value.length > 0 && value.every(scalar))
+        return value;
+    return undefined;
+}
+/** Narrows an `eq`/`in` operator into a hex RPC filter value. */
+function pushHex(op) {
+    const value = pushValue(op);
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value) && value.every((item) => typeof item === 'string'))
+        return value;
+    return undefined;
+}
 /** Narrows an `eq`/`in` address operator into the `getLogs` address pushdown. */
 function pushAddress(op) {
-    if (op === undefined)
+    return pushHex(op);
+}
+/** Parses a human-readable event signature without letting refinements throw. */
+function parseEvent(signature) {
+    if (!signature)
         return undefined;
-    if (typeof op === 'string')
-        return op;
-    if (typeof op === 'object' && op !== null) {
-        const o = op;
-        if (typeof o['eq'] === 'string')
-            return o['eq'];
-        if (Array.isArray(o['in']))
-            return o['in'].filter((v) => typeof v === 'string');
+    try {
+        const item = parseAbiItem(signature);
+        return item.type === 'event' ? item : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Returns exact indexed arguments that viem can push into `eth_getLogs`. */
+function pushEventArgs(args, event) {
+    const pushed = {};
+    for (const [name, op] of Object.entries(args ?? {})) {
+        const input = event.inputs.find((item) => item.indexed && item.name === name);
+        const value = pushValue(op);
+        if (input && value !== undefined)
+            pushed[name] = value;
+    }
+    return pushed;
+}
+/** Checks that the accepted filter has a selective `eth_getLogs` representation. */
+function hasLogPushdown(f) {
+    if (pushAddress(f.address) !== undefined)
+        return true;
+    const secondaryTopic = [f.topic1, f.topic2, f.topic3].some((topic) => pushHex(topic) !== undefined);
+    const event = parseEvent(f.signature);
+    if (event && !event.anonymous)
+        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.at(-1) === undefined)
+        topics.pop();
+    return topics.map((topic) => topic ?? null);
+}
+/** Converts one raw JSON-RPC log into the viem-shaped scanner input. */
+function fromRpcLog(log) {
+    return {
+        address: log.address,
+        blockNumber: log.blockNumber === null ? null : BigInt(log.blockNumber),
+        data: log.data,
+        logIndex: Value.hexToNumber(log.logIndex) ?? null,
+        topics: log.topics,
+        transactionHash: log.transactionHash,
+        transactionIndex: Value.hexToNumber(log.transactionIndex) ?? null,
+    };
+}
+/** Best-effort decodes a raw log using the subscription event. */
+function decodeScanLog(log, event) {
+    try {
+        const decoded = decodeEventLog({
+            abi: [event],
+            data: log.data,
+            strict: false,
+            topics: log.topics,
+        });
+        return {
+            ...log,
+            args: decoded.args,
+            eventName: decoded.eventName,
+        };
+    }
+    catch {
+        return log;
     }
-    // `not`/range forms can't be pushed; widen here, re-check in JS.
-    return undefined;
 }
 /**
- * Scans contract event logs over the confirmed window via viem's `getLogs`,
- * then re-checks **every** filter in JS (so operators the RPC can't express —
- * `not`, ranges, decoded `args` — still apply). Two modes:
+ * Scans contract event logs over the confirmed window via `eth_getLogs`,
+ * then re-checks **every** filter in JS. Operators the RPC cannot express
+ * (`not`, ranges, non-indexed `args`) still apply. Two modes:
  * - **raw** (no `signature`): `topic0..3` are matched directly.
- * - **decoded** (`signature` present): `getLogs` is given the `event`, so it
- *   pushes the event selector down, filters to matching logs, and best-effort
- *   decodes `args` — which the JS pass then matches by name.
+ * - **decoded** (`signature` present): the selector, raw topics, and supported
+ *   indexed `args` are pushed down before the JS pass matches decoded values.
  *
- * `address` (`eq`/`in`) is pushed down to the node; all other operators are
- * re-checked in JS over the narrow window.
+ * Exact and membership address/topic operators are pushed down to the node;
+ * all operators are re-checked in JS over the narrow window.
  */
 async function scanLogs(options) {
     const { cache, client, cursor, filters, maxBlocks, safeBlock } = options;
@@ -1773,26 +1886,35 @@ async function scanLogs(options) {
     const window = scanWindow(cursor, safeBlock, maxBlocks);
     if (!window)
         return { items: [], scannedThrough: undefined };
-    const event = f.signature ? parseAbiItem(f.signature) : undefined;
-    if (event && !/^[A-Za-z_]\w*$/.test(event.name))
+    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 fromBlock = BigInt(window.from);
     const toBlock = BigInt(window.to);
-    const logs = (event
-        ? await client.getLogs({
+    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,
             strict: false,
             toBlock,
-        })
-        : await client.getLogs({
-            ...(address ? { address } : {}),
-            fromBlock,
-            toBlock,
         }));
     logs.sort((a, b) => {
         const ab = Number(a.blockNumber ?? 0n);
@@ -2077,7 +2199,7 @@ function toPublic(subscription) {
         chainId: subscription.chainId,
         ...(subscription.context === undefined ? {} : { context: subscription.context }),
         createdAt: subscription.createdAt,
-        destination: subscription.destination,
+        destination: redactDestination(subscription.destination),
         eventType: subscription.eventType,
         ...(subscription.expiresAt === undefined ? {} : { expiresAt: subscription.expiresAt }),
         failureCount: subscription.failureCount,
@@ -2092,7 +2214,19 @@ function toPublic(subscription) {
 }
 /** Public read shape plus the one-time signing secret (creation only). */
 function toCreated(subscription) {
-    return { ...toPublic(subscription), secret: subscription.secret };
+    return {
+        ...toPublic(subscription),
+        destination: subscription.destination,
+        secret: subscription.secret,
+    };
+}
+/** Redacts bearer credentials from the destination returned by read endpoints. */
+function redactDestination(destination) {
+    if (destination.type === 'slack')
+        return { ...destination, url: redactedSlackUrl };
+    if (destination.type === 'betterstack')
+        return { ...destination, token: redactedBetterstackToken };
+    return destination;
 }
 function mutationError(c, cause) {
     if (cause instanceof Webhooks.InvalidUrlError)