tapimo 0.10.0 → 0.10.2

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

@@ -376,7 +376,7 @@ export var schema;
         sender: Schema.Address.check(z.describe('Address that sent the transfer.'), z.meta({ examples: ['0xe7687128b0a808c2831ff94d4f7b2fb35c65af38'] })),
         timestamp: z.iso
             .datetime()
-            .check(z.describe('Block timestamp as an ISO 8601 string.'), z.meta({ examples: ['2026-01-14T18:38:03.000Z'] })),
+            .check(z.describe('Block timestamp as an ISO 8601 string.'), z.meta({ examples: ['2026-01-14T18:38:03.685Z'] })),
         token: z.optional(z
             .object({
             decimals: z
@@ -444,7 +444,7 @@ export var schema;
             .check(z.int(), z.nonnegative(), z.describe('Index of the log within its block.'), z.meta({ examples: [0] })),
         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.000Z'] })),
+            .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({
             examples: [
                 [
@@ -486,7 +486,7 @@ export var schema;
             .check(z.int(), z.nonnegative(), z.describe('Number of transactions included in this block.'), z.meta({ examples: [3] })),
         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.000Z'] })),
+            .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).'));
     /** A `ping` (synthetic test-delivery) payload, sent by `POST /webhooks/:id/ping`. */
@@ -1659,15 +1659,11 @@ export async function poll(options) {
                         // 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 = eventType === 'token:transfer'
-                            ? await withTokenMetadata(item.data, { cache: cache_metadata, chainId, client })
-                            : eventType === 'transaction:included'
-                                ? await withFeeTokenMetadata(item.data, {
-                                    cache: cache_metadata,
-                                    chainId,
-                                    client,
-                                })
-                                : item.data;
+                        const data = await enrichEventData(eventType, item.data, {
+                            cache: cache_metadata,
+                            chainId,
+                            client,
+                        });
                         durations.enrich += Date.now() - enrichStartedAt;
                         observed.add('enrich');
                         options.signal?.throwIfAborted();
@@ -1685,7 +1681,7 @@ export async function poll(options) {
                         for (const item of page.items)
                             dispatchables.push(await buildDispatchable(item));
                         options.signal?.throwIfAborted();
-                        const delivered = await dispatchBatch(dispatchables);
+                        const delivered = await dispatchBatch(dispatchables, { db });
                         if (delivered.ok) {
                             accepted = page.items.at(-1)?.cursor;
                             result.dispatched += dispatchables.length;
@@ -2237,6 +2233,17 @@ function decodeScanLog(log, event) {
         return log;
     }
 }
+/**
+ * Attaches best-effort token metadata to one matched row before delivery.
+ * Transfers gain display metadata; transactions resolve their fee token.
+ */
+export async function enrichEventData(eventType, data, options) {
+    if (eventType === 'token:transfer')
+        return withTokenMetadata(data, options);
+    if (eventType === 'transaction:included')
+        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;
@@ -2286,7 +2293,7 @@ async function scanLogs(options) {
             continue;
         if (!matchesLog(log, f, event))
             continue;
-        const data = toLogEvent(log, blockIso(await cache.header(blockNumber)), f.signature, event);
+        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)
@@ -2338,13 +2345,6 @@ function matchesLog(log, f, event) {
     }
     return true;
 }
-// block:created (getBlock)
-/** Converts a viem block's `timestamp` (seconds) to an ISO 8601 string. */
-function blockIso(block) {
-    if (!block || typeof block.timestamp !== 'bigint')
-        return undefined;
-    return new Date(Number(block.timestamp) * 1000).toISOString();
-}
 /** Builds the delivered `block:created` payload from a viem block header. */
 function toBlockEvent(block) {
     const number = block.number === null ? undefined : Number(block.number);
@@ -2353,7 +2353,7 @@ function toBlockEvent(block) {
     const miner = Schema.Address.safeParse(block.miner);
     const gasUsed = typeof block.gasUsed === 'bigint' ? Number(block.gasUsed) : undefined;
     const gasLimit = typeof block.gasLimit === 'bigint' ? Number(block.gasLimit) : undefined;
-    const timestamp = blockIso(block);
+    const timestamp = Value.blockToIso(block);
     const transactionCount = Array.isArray(block.transactions) ? block.transactions.length : 0;
     if (number === undefined ||
         !hash.success ||
@@ -2449,6 +2449,9 @@ async function scanTxs(options) {
             ? 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;
@@ -2459,7 +2462,8 @@ async function scanTxs(options) {
             const parsed = Transactions.schema.Rpc.Transaction.safeParse(transaction);
             if (!parsed.success)
                 continue;
-            const data = Transactions.humanizeTransaction(parsed.data);
+            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 };
@@ -2608,6 +2612,156 @@ function unauthorized(c) {
         status: 401,
     });
 }
+// Pure per-block scanning (no RPC, no cursors, no pagination).
+// Pure over its inputs: the caller fetches the raw block (with transactions)
+// and its logs; enrichment happens downstream. Rows require a parsable block number.
+/**
+ * Matches one fetched block against a subscription set, producing the rows
+ * each event type delivers. Invalid stored filters fail closed into `invalid`.
+ */
+export function scanBlock(options) {
+    const { block, logs, subscriptions } = options;
+    const blockNumber = Value.hexToNumber(block['number']);
+    const timestamp = Value.blockToIso(block);
+    const header = toScanHeader(block);
+    const viemLogs = logs.map(fromRpcLog);
+    const matches = [];
+    const invalid = [];
+    for (const subscription of subscriptions) {
+        const filters = (() => {
+            try {
+                return parseFilters(subscription.eventType, subscription.filters);
+            }
+            catch (error) {
+                invalid.push({ error, subscription });
+                return undefined;
+            }
+        })();
+        if (filters === undefined)
+            continue;
+        const matched = matches.length;
+        const push = (data, logIndex) => {
+            if (blockNumber !== undefined)
+                matches.push({ blockNumber, data, logIndex, subscription });
+        };
+        // A throwing matcher invalidates only this subscription, rolling back any
+        // rows it matched before the failure.
+        try {
+            switch (subscription.eventType) {
+                case 'block:created': {
+                    const f = filters;
+                    if (!matchesBlock(header, f))
+                        break;
+                    const data = toBlockEvent(header);
+                    if (data)
+                        push(data, 0);
+                    break;
+                }
+                case 'log:emitted': {
+                    const f = filters;
+                    const event = parseEvent(f.signature);
+                    if (f.signature && (!event || !/^[A-Za-z_]\w*$/.test(event.name))) {
+                        invalid.push({
+                            error: new Webhooks.InvalidFilterError('log:emitted', [
+                                { message: 'Unsupported event signature.', path: ['signature'] },
+                            ]),
+                            subscription,
+                        });
+                        break;
+                    }
+                    // Validate arg names up front so a bad filter fails closed even
+                    // when the block has no decodable logs.
+                    const unknown = event && f.args
+                        ? Object.keys(f.args).find((name) => !event.inputs.some((input) => input.name === name))
+                        : undefined;
+                    if (unknown !== undefined) {
+                        invalid.push({
+                            error: new Webhooks.InvalidFilterError('log:emitted', [
+                                { message: `Unknown event argument: ${unknown}.`, path: ['args', unknown] },
+                            ]),
+                            subscription,
+                        });
+                        break;
+                    }
+                    for (const log of viemLogs) {
+                        const decoded = event ? decodeScanLog(log, event) : log;
+                        const logIndex = decoded.logIndex ?? undefined;
+                        if (logIndex === undefined)
+                            continue;
+                        if (!matchesLog(decoded, f, event))
+                            continue;
+                        const data = toLogEvent(decoded, timestamp, f.signature, event);
+                        if (data)
+                            push(data, logIndex);
+                    }
+                    break;
+                }
+                case 'token:transfer': {
+                    if (timestamp === undefined)
+                        break;
+                    const f = filters;
+                    for (const log of logs) {
+                        const data = WebhookTransfer.decode(log, timestamp);
+                        if (!data || !WebhookTransfer.matches(data, f))
+                            continue;
+                        push(data, data.logIndex);
+                    }
+                    break;
+                }
+                case 'transaction:included': {
+                    const f = filters;
+                    const includeCalls = f.includeCalls ?? true;
+                    const transactions = Array.isArray(block['transactions'])
+                        ? block['transactions']
+                        : [];
+                    const rawTimestamp = asString(block['timestamp']);
+                    for (let offset = 0; offset < transactions.length; offset++) {
+                        const transaction = transactions[offset];
+                        if (!transaction || typeof transaction !== 'object')
+                            continue;
+                        const tx = transaction;
+                        const transactionIndex = Value.hexToNumber(tx['transactionIndex']) ?? offset;
+                        if (!matchesTx(tx, f, includeCalls, rawTimestamp, blockNumber ?? 0))
+                            continue;
+                        const parsed = Transactions.schema.Rpc.Transaction.safeParse(tx);
+                        if (!parsed.success)
+                            continue;
+                        const humanized = Transactions.humanizeTransaction(parsed.data);
+                        // A transaction's own timestamp is seconds-only; the enclosing
+                        // block carries milliseconds.
+                        push(timestamp === undefined ? humanized : { ...humanized, timestamp }, transactionIndex);
+                    }
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            matches.length = matched;
+            invalid.push({ error, subscription });
+        }
+    }
+    return { invalid, matches };
+}
+/** Normalizes a raw RPC header to the viem-shaped fields the block matchers read. */
+function toScanHeader(block) {
+    const quantity = (value) => {
+        try {
+            return typeof value === 'string' || typeof value === 'number' || typeof value === 'bigint'
+                ? BigInt(value)
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return {
+        ...block,
+        gasLimit: quantity(block['gasLimit']),
+        gasUsed: quantity(block['gasUsed']),
+        number: quantity(block['number']),
+        timestamp: quantity(block['timestamp']),
+    };
+}
 class BlockUnavailableError extends Error {
     name = 'Webhooks.BlockUnavailableError';
     constructor(blockNumber) {