tapimo 0.5.3 → 0.7.0

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

@@ -15,7 +15,7 @@ import * as Webhooks from '../../../internal/Webhooks.js';
 import * as Receipts from './receipts.js';
 import * as Transactions from './transactions.js';
 import * as Transfers from './transfers.js';
-/** Default cap on active subscriptions per owner, overridable via `webhook.maxPerOwner`. */
+/** Default cap on live subscriptions per owner, overridable via `webhook.maxPerOwner`. */
 const defaultMaxPerOwner = 100;
 /**
  * Lifetime of an MPP-payer-owned subscription. A payer pays once, so the
@@ -816,10 +816,13 @@ export function webhooks(options = {}) {
         responses: OpenApi.responses({
             errors: {
                 400: {
-                    codes: ['chain_id_unsupported'],
-                    description: 'Webhook subscriptions do not support Zone chains.',
+                    codes: ['body_invalid', 'chain_id_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.',
                 },
-                403: 'You have reached the webhook subscription limit.',
             },
             success: {
                 description: 'The created webhook subscription, including the one-time signing secret.',
@@ -845,12 +848,9 @@ export function webhooks(options = {}) {
             return unauthorized(c);
         const body = c.req.valid('json');
         const chainId = body.chainId ?? c.get('chainId');
-        if (c.get('zones').has(chainId))
-            return Response.error(c, {
-                code: 'chain_id_unsupported',
-                message: 'Webhook subscriptions do not support Zone chains.',
-                status: 400,
-            });
+        const supportedChainIds = new Set(webhook.supportedChainIds);
+        if (!supportedChainIds.has(chainId))
+            return Response.unsupportedChainId(c, chainId, supportedChainIds);
         try {
             const subscription = await Webhooks.createSubscription(db, {
                 chainId,
@@ -864,7 +864,7 @@ export function webhooks(options = {}) {
             return c.json(Response.validated(schema.createWebhook.Response, toCreated(subscription)), 200);
         }
         catch (cause) {
-            return mutationError(c, cause);
+            return createMutationError(c, cause);
         }
     })
         .get('/v1/webhooks', Auth.policy({ apiKey: { scopes: ['webhooks:read'] } }), OpenApi.validate('query', schema.listWebhooks.Query, {
@@ -1189,6 +1189,16 @@ export function webhooks(options = {}) {
         operationId: 'updateWebhook',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: [
+                        'body_invalid',
+                        'destination_transition_invalid',
+                        'filters_invalid',
+                        'param_invalid',
+                        'url_invalid',
+                    ],
+                    description: 'The update, destination, or filters are invalid.',
+                },
                 404: {
                     description: 'No webhook subscription was found for that ID.',
                     codes: ['webhook_not_found'],
@@ -1240,7 +1250,7 @@ export function webhooks(options = {}) {
             return c.json(Response.validated(schema.updateWebhook.Response, toPublic(subscription)), 200);
         }
         catch (cause) {
-            return mutationError(c, cause);
+            return updateMutationError(c, cause);
         }
     })
         .delete('/v1/webhooks/:id{wh_[A-Za-z0-9_-]+}', Auth.policy({ apiKey: { scopes: ['webhooks:write'] } }), OpenApi.validate('param', schema.deleteWebhook.Params, {
@@ -1376,12 +1386,13 @@ export async function poll(options) {
             let accepted;
             let failed = false;
             for (const item of page.items) {
-                // Enrich `token:transfer` rows with best-effort token metadata so
-                // downstream destinations (Slack human amounts, richer `url`/`betterstack`
-                // payloads) can render `amount` in token units. Non-fatal on failure.
+                // Token metadata is best-effort for webhooks: transfers use it for display,
+                // while transactions expose fee-token references without blocking delivery.
                 const data = eventType === 'token:transfer'
                     ? await withTokenMetadata(item.data, { cache: cache_metadata, chainId, client })
-                    : item.data;
+                    : eventType === 'transaction:included'
+                        ? await withFeeTokenMetadata(item.data, { cache: cache_metadata, chainId, client })
+                        : item.data;
                 const envelope = Webhooks.buildEnvelope({
                     blockNumber: item.cursor[0],
                     createdAt: now(),
@@ -1430,21 +1441,31 @@ async function withTokenMetadata(data, deps) {
     if (typeof address !== 'string')
         return data;
     const token = await resolveTokenMetadata(address, deps);
-    return token ? { ...data, token } : data;
+    return token
+        ? {
+            ...data,
+            token: { decimals: token.decimals, symbol: token.symbol },
+        }
+        : data;
 }
 /**
- * Resolves a token's `{ symbol, decimals }` via `token.getMetadata`, memoized per
+ * Resolves core token metadata via `token.getMetadata`, memoized per
  * `(chainId, address)` with a short TTL so a busy transfer stream shares one RPC
- * lookup per token. Returns `undefined` on any failure — metadata is a rendering
+ * lookup per token. Returns `undefined` on any failure; metadata is a rendering
  * nicety, never a delivery blocker.
  */
 async function resolveTokenMetadata(address, deps) {
     try {
         return await Store.memoize(async () => {
             const meta = await deps.client.token.getMetadata({ token: address });
-            return { decimals: meta.decimals, symbol: meta.symbol };
+            return {
+                currency: meta.currency,
+                decimals: meta.decimals,
+                name: meta.name,
+                symbol: meta.symbol,
+            };
         }, {
-            key: `webhook:token-meta:v1:${deps.chainId}:${address}`,
+            key: `webhook:token-meta:v2:${deps.chainId}:${address}`,
             store: deps.cache,
             ttl: Ttl.minutes(5),
         });
@@ -1454,6 +1475,60 @@ async function resolveTokenMetadata(address, deps) {
         return undefined;
     }
 }
+/** Returns the address from an unenriched or enriched fee-token value. */
+function feeTokenAddress(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const address = value['address'];
+    return typeof address === 'string' ? address : undefined;
+}
+/** Replaces an address-valued fee token with its resolved reference, or omits it on failure. */
+function withResolvedFeeToken(data, metadata) {
+    const address = feeTokenAddress(data['feeToken']);
+    if (!address)
+        return data;
+    const result = { ...data };
+    delete result['feeToken'];
+    const token = metadata.get(address.toLowerCase());
+    if (token)
+        result['feeToken'] = { address, ...token };
+    return result;
+}
+/** Adds best-effort fee-token references to a transaction and its embedded receipt. */
+async function withFeeTokenMetadata(data, deps) {
+    if (typeof data !== 'object' || data === null)
+        return data;
+    const transaction = data;
+    const meta = transaction['meta'];
+    const receipt = typeof meta === 'object' && meta !== null
+        ? meta['receipt']
+        : undefined;
+    const addresses = new Set();
+    const transactionAddress = feeTokenAddress(transaction['feeToken']);
+    if (transactionAddress)
+        addresses.add(transactionAddress.toLowerCase());
+    if (typeof receipt === 'object' && receipt !== null) {
+        const receiptAddress = feeTokenAddress(receipt['feeToken']);
+        if (receiptAddress)
+            addresses.add(receiptAddress.toLowerCase());
+    }
+    if (addresses.size === 0)
+        return data;
+    const resolved = await Promise.all([...addresses].map(async (address) => [address, await resolveTokenMetadata(address, deps)]));
+    const metadata = new Map(resolved.filter((entry) => entry[1] !== undefined));
+    const result = withResolvedFeeToken(transaction, metadata);
+    if (typeof receipt !== 'object' || receipt === null)
+        return result;
+    return {
+        ...result,
+        meta: {
+            ...meta,
+            receipt: withResolvedFeeToken(receipt, metadata),
+        },
+    };
+}
 /** Returns the live RPC head block number for the chain. */
 export async function getRpcHead(client) {
     return Number(await client.getBlockNumber());
@@ -2080,8 +2155,8 @@ const txFields = {
  * Scans included transactions over the confirmed window. Each block is fetched
  * with full transactions via `eth_getBlockByNumber(n, true)`; receipts are
  * fetched lazily (only when a `status`/`gasUsed`/`feePayer` filter needs them).
- * The delivered payload reuses `Transactions.humanizeTransaction`, so it is
- * byte-identical to the read endpoint.
+ * The delivered payload starts from `Transactions.humanizeTransaction`; the
+ * poller then resolves its fee-token references.
  */
 async function scanTxs(options) {
     const { cache, cursor, filters, maxBlocks, safeBlock } = options;
@@ -2121,7 +2196,13 @@ async function scanTxs(options) {
             if (includeReceipt && receipt) {
                 const r = Receipts.schema.Rpc.Receipt.safeParse(receipt);
                 if (r.success)
-                    data = { ...data, meta: { ...data.meta, receipt: Receipts.humanizeReceipt(r.data) } };
+                    data = {
+                        ...data,
+                        meta: {
+                            ...data['meta'],
+                            receipt: Receipts.humanizeReceipt(r.data),
+                        },
+                    };
             }
             items.push({ cursor: [n, index], data });
         }
@@ -2228,7 +2309,7 @@ function redactDestination(destination) {
         return { ...destination, token: redactedBetterstackToken };
     return destination;
 }
-function mutationError(c, cause) {
+function createMutationError(c, cause) {
     if (cause instanceof Webhooks.InvalidUrlError)
         return Response.error(c, { code: 'url_invalid', message: cause.message, status: 400 });
     if (cause instanceof Webhooks.InvalidFilterError)
@@ -2242,6 +2323,24 @@ function mutationError(c, cause) {
         return Response.error(c, { code: 'limit_exceeded', message: cause.message, status: 403 });
     return Response.upstream(c, cause);
 }
+function updateMutationError(c, cause) {
+    if (cause instanceof Webhooks.InvalidDestinationTransitionError)
+        return Response.error(c, {
+            code: 'destination_transition_invalid',
+            message: cause.message,
+            status: 400,
+        });
+    if (cause instanceof Webhooks.InvalidUrlError)
+        return Response.error(c, { code: 'url_invalid', message: cause.message, status: 400 });
+    if (cause instanceof Webhooks.InvalidFilterError)
+        return Response.error(c, {
+            code: 'filters_invalid',
+            details: cause.details,
+            message: cause.message,
+            status: 400,
+        });
+    return Response.upstream(c, cause);
+}
 function notFound(c) {
     return Response.error(c, {
         code: 'webhook_not_found',