@farcaster/snap 2.9.0 → 2.10.0

package/dist/render-state.d.ts

@@ -5,6 +5,15 @@ export type SnapRenderStateChanges = {
 }[] | Record<string, unknown> | null | undefined;
 export declare function cloneSnapRenderState<T>(value: T): T;
 export declare function applyStatePaths(model: Record<string, unknown>, changes: SnapRenderStateChanges): void;
+export declare function buildActionActivityStateChanges({ actionName, params, pending, }: {
+    actionName: unknown;
+    params: Record<string, unknown>;
+    pending: boolean;
+}): {
+    path: string;
+    value: unknown;
+}[];
+export declare function hasPendingSnapAction(model: SnapRenderState): boolean;
 export declare function getUnpresentedSnapEffects(model: SnapRenderState, effects: readonly string[] | undefined): string[];
 export declare function markSnapEffectsPresented(model: SnapRenderState, effects: readonly string[] | undefined): boolean;
 export declare function buildInitialRenderState({ specState, initialRenderState, themeAccent, }: {

package/dist/render-state.js

@@ -1,4 +1,5 @@
 const SNAP_RENDER_STATE_META_KEY = "__snapRender";
+const ACTION_ACTIVITY_KEY_MAX_LENGTH = 64;
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -75,6 +76,32 @@ export function applyStatePaths(model, changes) {
         setStateValue(model, parts, value);
     }
 }
+function sanitizeActionActivityKey(value) {
+    const sanitized = value
+        .trim()
+        .slice(0, ACTION_ACTIVITY_KEY_MAX_LENGTH)
+        .replace(/[^A-Za-z0-9_.-]/g, "_");
+    return sanitized || "action";
+}
+function getActionActivityKey(actionName, params) {
+    const explicitKey = params.activityKey;
+    return sanitizeActionActivityKey(typeof explicitKey === "string" && explicitKey.trim()
+        ? explicitKey
+        : String(actionName || "action"));
+}
+export function buildActionActivityStateChanges({ actionName, params, pending, }) {
+    const key = getActionActivityKey(actionName, params);
+    return [
+        { path: `/actions/${key}/name`, value: String(actionName || "action") },
+        { path: `/actions/${key}/pending`, value: pending },
+    ];
+}
+export function hasPendingSnapAction(model) {
+    const actions = model.actions;
+    if (!isRecord(actions))
+        return false;
+    return Object.values(actions).some((action) => isRecord(action) && action.pending === true);
+}
 export function getUnpresentedSnapEffects(model, effects) {
     const presentedEffects = getPresentedSnapEffects(model);
     return normalizeEffects(effects).filter((effect) => !presentedEffects.has(effect));

package/dist/schemas.d.ts

@@ -69,9 +69,34 @@ export type SnapHandlerResult = {
     effects?: z.input<typeof snapResponseSchema>["effects"];
     ui: SnapSpecInput;
 };
+declare const snapSendTransactionParamsSchema: z.ZodObject<{
+    chainId: z.ZodString;
+    to: z.ZodString;
+    data: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+    gas: z.ZodOptional<z.ZodString>;
+    gasPrice: z.ZodOptional<z.ZodString>;
+    maxFeePerGas: z.ZodOptional<z.ZodString>;
+    maxPriorityFeePerGas: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SnapSendTransactionParams = z.infer<typeof snapSendTransactionParamsSchema>;
+export declare const snapTransactionResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    transactionHash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    reason: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        rejected_by_user: "rejected_by_user";
+        failed: "failed";
+    }>>>;
+    message: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    transactionHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "success">;
+export type SnapTransactionResult = z.infer<typeof snapTransactionResultSchema>;
 export declare const payloadSchema: z.ZodObject<{
     fid: z.ZodOptional<z.ZodNumber>;
-    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
     timestamp: z.ZodNumber;
     audience: z.ZodString;
     user: z.ZodObject<{
@@ -88,6 +113,7 @@ export declare const payloadSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"standalone">;
     }, z.core.$strip>], "type">;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
 }, z.core.$strip>;
 export type SnapPayload = z.infer<typeof payloadSchema>;
 /** JFS payload shape for POST minus deprecated `fid`; used for GET auth via payload header. */
@@ -112,6 +138,7 @@ export declare const getPayloadSchema: z.ZodObject<{
 export type SnapGetPayload = z.infer<typeof getPayloadSchema>;
 export declare const ACTION_TYPE_GET: "get";
 export declare const ACTION_TYPE_POST: "post";
+export declare const ACTION_TYPE_TRANSACTION_RESULT: "transaction_result";
 declare const snapGetActionSchema: z.ZodObject<{
     type: z.ZodLiteral<"get">;
     user: z.ZodOptional<z.ZodObject<{
@@ -134,7 +161,6 @@ declare const snapGetActionSchema: z.ZodObject<{
 export type SnapGetAction = z.infer<typeof snapGetActionSchema>;
 declare const snapPostActionSchema: z.ZodObject<{
     fid: z.ZodOptional<z.ZodNumber>;
-    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
     timestamp: z.ZodNumber;
     audience: z.ZodString;
     user: z.ZodObject<{
@@ -151,9 +177,58 @@ declare const snapPostActionSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"standalone">;
     }, z.core.$strip>], "type">;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
     type: z.ZodLiteral<"post">;
 }, z.core.$strip>;
 export type SnapPostAction = z.infer<typeof snapPostActionSchema>;
+export declare const transactionResultPayloadSchema: z.ZodObject<{
+    fid: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodNumber;
+    audience: z.ZodString;
+    user: z.ZodObject<{
+        fid: z.ZodNumber;
+    }, z.core.$strip>;
+    surface: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"cast">;
+        cast: z.ZodObject<{
+            hash: z.ZodString;
+            author: z.ZodObject<{
+                fid: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"standalone">;
+    }, z.core.$strip>], "type">;
+    type: z.ZodLiteral<"transaction_result">;
+    transaction: z.ZodObject<{
+        request: z.ZodObject<{
+            chainId: z.ZodString;
+            to: z.ZodString;
+            data: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodString>;
+            gas: z.ZodOptional<z.ZodString>;
+            gasPrice: z.ZodOptional<z.ZodString>;
+            maxFeePerGas: z.ZodOptional<z.ZodString>;
+            maxPriorityFeePerGas: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            success: z.ZodLiteral<true>;
+            transactionHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            success: z.ZodLiteral<false>;
+            reason: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                unknown: "unknown";
+                rejected_by_user: "rejected_by_user";
+                failed: "failed";
+            }>>>;
+            message: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            transactionHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "success">;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export type SnapTransactionResultPayload = z.infer<typeof transactionResultPayloadSchema>;
+export type SnapTransactionResultAction = SnapTransactionResultPayload;
 export declare const snapActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"get">;
     user: z.ZodOptional<z.ZodObject<{
@@ -174,7 +249,6 @@ export declare const snapActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>], "type">>;
 }, z.core.$strip>, z.ZodObject<{
     fid: z.ZodOptional<z.ZodNumber>;
-    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
     timestamp: z.ZodNumber;
     audience: z.ZodString;
     user: z.ZodObject<{
@@ -191,7 +265,53 @@ export declare const snapActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"standalone">;
     }, z.core.$strip>], "type">;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
     type: z.ZodLiteral<"post">;
+}, z.core.$strip>, z.ZodObject<{
+    fid: z.ZodOptional<z.ZodNumber>;
+    timestamp: z.ZodNumber;
+    audience: z.ZodString;
+    user: z.ZodObject<{
+        fid: z.ZodNumber;
+    }, z.core.$strip>;
+    surface: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"cast">;
+        cast: z.ZodObject<{
+            hash: z.ZodString;
+            author: z.ZodObject<{
+                fid: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"standalone">;
+    }, z.core.$strip>], "type">;
+    type: z.ZodLiteral<"transaction_result">;
+    transaction: z.ZodObject<{
+        request: z.ZodObject<{
+            chainId: z.ZodString;
+            to: z.ZodString;
+            data: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodString>;
+            gas: z.ZodOptional<z.ZodString>;
+            gasPrice: z.ZodOptional<z.ZodString>;
+            maxFeePerGas: z.ZodOptional<z.ZodString>;
+            maxPriorityFeePerGas: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            success: z.ZodLiteral<true>;
+            transactionHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            success: z.ZodLiteral<false>;
+            reason: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                unknown: "unknown";
+                rejected_by_user: "rejected_by_user";
+                failed: "failed";
+            }>>>;
+            message: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            transactionHash: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "success">;
+    }, z.core.$strict>;
 }, z.core.$strip>], "type">;
 export type SnapAction = z.infer<typeof snapActionSchema>;
 export type SnapContext = {

package/dist/schemas.js

@@ -49,20 +49,59 @@ const surfaceSchema = z.discriminatedUnion("type", [
 ]);
 const fidSchema = z.number().int().nonnegative();
 const userSchema = z.object({ fid: fidSchema });
-export const payloadSchema = z
+const basePayloadSchema = z
     .object({
     fid: fidSchema.optional(), // deprecated in favor of user.fid
-    inputs: z.record(z.string(), postInputValueSchema).default({}),
     timestamp: z.number().int(),
     audience: z.string(),
     user: userSchema,
     surface: surfaceSchema,
 })
     .strip();
+const snapSendTransactionParamsSchema = z
+    .object({
+    chainId: z.string(),
+    to: z.string(),
+    data: z.string().optional(),
+    value: z.string().optional(),
+    gas: z.string().optional(),
+    gasPrice: z.string().optional(),
+    maxFeePerGas: z.string().optional(),
+    maxPriorityFeePerGas: z.string().optional(),
+})
+    .strict();
+const snapTransactionSuccessSchema = z
+    .object({
+    success: z.literal(true),
+    transactionHash: z.string(),
+})
+    .strict();
+const snapTransactionFailureSchema = z
+    .object({
+    success: z.literal(false),
+    reason: z
+        .enum(["rejected_by_user", "failed", "unknown"])
+        .optional()
+        .default("unknown"),
+    message: z.string().optional(),
+    code: z.union([z.string(), z.number()]).optional(),
+    transactionHash: z.string().optional(),
+})
+    .strict();
+export const snapTransactionResultSchema = z.discriminatedUnion("success", [
+    snapTransactionSuccessSchema,
+    snapTransactionFailureSchema,
+]);
+export const payloadSchema = basePayloadSchema
+    .extend({
+    inputs: z.record(z.string(), postInputValueSchema).default({}),
+})
+    .strip();
 /** JFS payload shape for POST minus deprecated `fid`; used for GET auth via payload header. */
 export const getPayloadSchema = payloadSchema.omit({ inputs: true, fid: true });
 export const ACTION_TYPE_GET = "get";
 export const ACTION_TYPE_POST = "post";
+export const ACTION_TYPE_TRANSACTION_RESULT = "transaction_result";
 const snapGetActionSchema = z.object({
     type: z.literal(ACTION_TYPE_GET),
     user: userSchema.optional(),
@@ -73,7 +112,19 @@ const snapGetActionSchema = z.object({
 const snapPostActionSchema = payloadSchema.extend({
     type: z.literal(ACTION_TYPE_POST),
 });
+export const transactionResultPayloadSchema = basePayloadSchema
+    .extend({
+    type: z.literal(ACTION_TYPE_TRANSACTION_RESULT),
+    transaction: z
+        .object({
+        request: snapSendTransactionParamsSchema,
+        result: snapTransactionResultSchema,
+    })
+        .strict(),
+})
+    .strip();
 export const snapActionSchema = z.discriminatedUnion("type", [
     snapGetActionSchema,
     snapPostActionSchema,
+    transactionResultPayloadSchema,
 ]);

package/dist/server/parseRequest.js

@@ -1,4 +1,4 @@
-import { ACTION_TYPE_GET, ACTION_TYPE_POST, getPayloadSchema, payloadSchema, } from "../schemas.js";
+import { ACTION_TYPE_TRANSACTION_RESULT, ACTION_TYPE_GET, ACTION_TYPE_POST, getPayloadSchema, payloadSchema, transactionResultPayloadSchema, } from "../schemas.js";
 import { decodePayload, parseJfs, verifyJFS } from "./verify.js";
 import { SNAP_PAYLOAD_HEADER } from "../constants.js";
 const DEFAULT_SNAP_POST_MAX_SKEW_SECONDS = 300;
@@ -46,7 +46,9 @@ async function parseGetRequest(request, options) {
 async function parsePostRequest(request, options) {
     const result = await validateJfsPayload({
         jfsText: await request.text(),
-        schema: payloadSchema,
+        schema: (decodedPayload) => isTransactionResultPayload(decodedPayload)
+            ? transactionResultPayloadSchema
+            : payloadSchema,
         request,
         options,
     });
@@ -63,11 +65,23 @@ async function parsePostRequest(request, options) {
             },
         };
     }
+    if (isTransactionResultPayload(payload)) {
+        return {
+            success: true,
+            action: payload,
+        };
+    }
     return {
         success: true,
         action: { type: ACTION_TYPE_POST, ...payload },
     };
 }
+function isTransactionResultPayload(payload) {
+    return (payload !== null &&
+        typeof payload === "object" &&
+        "type" in payload &&
+        payload.type === ACTION_TYPE_TRANSACTION_RESULT);
+}
 /**
  * Shared pipeline for authenticated snap requests: parse the JFS envelope,
  * decode and schema-validate the payload, optionally verify the JFS signature
@@ -88,7 +102,9 @@ async function validateJfsPayload({ jfsText, schema, request, options, invalidJs
         };
     }
     const jfs = parsed.jfs;
-    const payloadParsed = schema.safeParse(decodePayload(jfs.payload));
+    const decodedPayload = decodePayload(jfs.payload);
+    const selectedSchema = typeof schema === "function" ? schema(decodedPayload) : schema;
+    const payloadParsed = selectedSchema.safeParse(decodedPayload);
     if (!payloadParsed.success) {
         return {
             ok: false,

package/dist/ui/button.d.ts

@@ -42,5 +42,6 @@ export declare const buttonProps: z.ZodObject<{
         "trending-up": "trending-up";
         "trending-down": "trending-down";
     }>>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ButtonProps = z.infer<typeof buttonProps>;

package/dist/ui/button.js

@@ -6,4 +6,5 @@ export const buttonProps = z.object({
     label: z.string().min(1).max(BUTTON_MAX_LABEL_CHARS),
     variant: z.enum(BUTTON_VARIANTS).optional(),
     icon: z.enum(ICON_NAMES).optional(),
+    disabled: z.boolean().optional(),
 });

package/dist/ui/catalog.d.ts

@@ -136,6 +136,7 @@ export declare const snapJsonRenderCatalog: import("@json-render/core").Catalog<
                     "trending-up": "trending-up";
                     "trending-down": "trending-down";
                 }>>;
+                disabled: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>;
             description: string;
         };
@@ -509,48 +510,56 @@ export declare const snapJsonRenderCatalog: import("@json-render/core").Catalog<
         submit: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 target: z.ZodString;
             }, z.core.$strip>;
         };
         open_url: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 target: z.ZodString;
             }, z.core.$strip>;
         };
         open_snap: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 target: z.ZodString;
             }, z.core.$strip>;
         };
         open_mini_app: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 target: z.ZodString;
             }, z.core.$strip>;
         };
         view_cast: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 hash: z.ZodString;
             }, z.core.$strip>;
         };
         view_profile: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 fid: z.ZodNumber;
             }, z.core.$strip>;
         };
         view_channel: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 channelKey: z.ZodString;
             }, z.core.$strip>;
         };
         compose_cast: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 text: z.ZodOptional<z.ZodString>;
                 channelKey: z.ZodOptional<z.ZodString>;
                 embeds: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -559,12 +568,14 @@ export declare const snapJsonRenderCatalog: import("@json-render/core").Catalog<
         view_token: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 token: z.ZodString;
             }, z.core.$strip>;
         };
         send_token: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 token: z.ZodString;
                 amount: z.ZodOptional<z.ZodString>;
                 recipientFid: z.ZodOptional<z.ZodNumber>;
@@ -574,6 +585,7 @@ export declare const snapJsonRenderCatalog: import("@json-render/core").Catalog<
         swap_token: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 sellToken: z.ZodOptional<z.ZodString>;
                 buyToken: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>;
@@ -581,6 +593,7 @@ export declare const snapJsonRenderCatalog: import("@json-render/core").Catalog<
         send_transaction: {
             description: string;
             params: z.ZodObject<{
+                activityKey: z.ZodOptional<z.ZodString>;
                 chainId: z.ZodString;
                 to: z.ZodString;
                 data: z.ZodOptional<z.ZodString>;

package/dist/ui/catalog.js

@@ -21,6 +21,9 @@ import { cellGridProps } from "./cell-grid.js";
 const snapClientParams = z.object({
     client_action: z.record(z.string(), z.unknown()),
 });
+const activityParams = {
+    activityKey: z.string().min(1).max(64).optional(),
+};
 /**
  * json-render catalog for snap elements.
  *
@@ -101,31 +104,31 @@ export const snapJsonRenderCatalog = defineCatalog(snapJsonRenderSchema, {
     actions: {
         submit: {
             description: "POST to snap server with signed body (fid, inputs, timestamp, signature); response is next snap page.",
-            params: z.object({ target: z.string() }),
+            params: z.object({ target: z.string(), ...activityParams }),
         },
         open_url: {
             description: "Open external URL in browser.",
-            params: z.object({ target: z.string() }),
+            params: z.object({ target: z.string(), ...activityParams }),
         },
         open_snap: {
             description: "Open a snap URL inline. The client renders the target as a snap rather than opening a browser.",
-            params: z.object({ target: z.string() }),
+            params: z.object({ target: z.string(), ...activityParams }),
         },
         open_mini_app: {
             description: "Open target URL as a Farcaster mini app.",
-            params: z.object({ target: z.string() }),
+            params: z.object({ target: z.string(), ...activityParams }),
         },
         view_cast: {
             description: "Navigate to a cast by hash.",
-            params: z.object({ hash: z.string() }),
+            params: z.object({ hash: z.string(), ...activityParams }),
         },
         view_profile: {
             description: "Navigate to a user profile by FID.",
-            params: z.object({ fid: z.number() }),
+            params: z.object({ fid: z.number(), ...activityParams }),
         },
         view_channel: {
             description: "Navigate to a Farcaster channel by channel key.",
-            params: z.object({ channelKey: z.string() }),
+            params: z.object({ channelKey: z.string(), ...activityParams }),
         },
         compose_cast: {
             description: "Open the cast composer with optional pre-filled content.",
@@ -133,11 +136,12 @@ export const snapJsonRenderCatalog = defineCatalog(snapJsonRenderSchema, {
                 text: z.string().optional(),
                 channelKey: z.string().optional(),
                 embeds: z.array(z.string()).optional(),
+                ...activityParams,
             }),
         },
         view_token: {
             description: "View a token in the wallet. Token is a CAIP-19 identifier.",
-            params: z.object({ token: z.string() }),
+            params: z.object({ token: z.string(), ...activityParams }),
         },
         send_token: {
             description: "Open send flow for a token. Token is CAIP-19.",
@@ -146,6 +150,7 @@ export const snapJsonRenderCatalog = defineCatalog(snapJsonRenderSchema, {
                 amount: z.string().optional(),
                 recipientFid: z.number().optional(),
                 recipientAddress: z.string().optional(),
+                ...activityParams,
             }),
         },
         swap_token: {
@@ -153,6 +158,7 @@ export const snapJsonRenderCatalog = defineCatalog(snapJsonRenderSchema, {
             params: z.object({
                 sellToken: z.string().optional(),
                 buyToken: z.string().optional(),
+                ...activityParams,
             }),
         },
         send_transaction: {
@@ -166,6 +172,7 @@ export const snapJsonRenderCatalog = defineCatalog(snapJsonRenderSchema, {
                 gasPrice: z.string().optional(),
                 maxFeePerGas: z.string().optional(),
                 maxPriorityFeePerGas: z.string().optional(),
+                ...activityParams,
             }),
         },
         paginator_next: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@farcaster/snap",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "Farcaster Snaps 🫰",
   "repository": {
     "type": "git",

package/src/index.ts

@@ -32,11 +32,15 @@ export {
 export {
   ACTION_TYPE_GET,
   ACTION_TYPE_POST,
+  ACTION_TYPE_TRANSACTION_RESULT,
   snapResponseSchema,
   payloadSchema,
   getPayloadSchema,
+  transactionResultPayloadSchema,
+  snapTransactionResultSchema,
   type SnapAction,
   type SnapGetAction,
+  type SnapTransactionResultAction,
   type SnapContext,
   type SnapResponse,
   type SnapHandlerResult,
@@ -45,6 +49,9 @@ export {
   type SnapFunction,
   type SnapPayload,
   type SnapGetPayload,
+  type SnapSendTransactionParams,
+  type SnapTransactionResult,
+  type SnapTransactionResultPayload,
 } from "./schemas";
 export { validateSnapResponse, type ValidationResult } from "./validator";
 export type { SnapRenderState } from "./render-state";

package/src/react/catalog-renderer.tsx

@@ -1,6 +1,12 @@
 "use client";
 
-import { createRenderer } from "@json-render/react";
+import {
+  JSONUIProvider,
+  Renderer,
+  type ComponentRegistry,
+  type CreateRendererProps,
+} from "@json-render/react";
+import { useMemo, type ReactNode } from "react";
 import { snapJsonRenderCatalog } from "@farcaster/snap/ui";
 import { SnapActionButton } from "./components/action-button";
 import { SnapBadge } from "./components/badge";
@@ -24,7 +30,7 @@ import { SnapCellGrid } from "./components/cell-grid";
  * Maps snap json-render catalog types to React components.
  * Keys match the snap wire-format `type` strings exactly.
  */
-export const SnapCatalogView = createRenderer(snapJsonRenderCatalog, {
+const snapCatalogRegistry = {
   badge: SnapBadge,
   button: SnapActionButton,
   icon: SnapIcon,
@@ -42,4 +48,52 @@ export const SnapCatalogView = createRenderer(snapJsonRenderCatalog, {
   toggle_group: SnapToggleGroup,
   bar_chart: SnapBarChart,
   cell_grid: SnapCellGrid,
-});
+} satisfies ComponentRegistry;
+
+export function SnapCatalogView({
+  spec,
+  store,
+  state,
+  onAction,
+  onStateChange,
+  functions,
+  loading,
+  fallback,
+  children,
+}: CreateRendererProps & { children?: ReactNode }) {
+  const actionHandlers = useMemo(
+    () =>
+      onAction
+        ? new Proxy<Record<string, (params: Record<string, unknown>) => unknown>>(
+            {},
+            {
+              get: (_target, prop) => {
+                return (params: Record<string, unknown>) =>
+                  onAction(String(prop), params);
+              },
+              has: () => true,
+            },
+          )
+        : undefined,
+    [onAction],
+  );
+
+  return (
+    <JSONUIProvider
+      registry={snapCatalogRegistry}
+      store={store}
+      initialState={state}
+      handlers={actionHandlers}
+      functions={functions}
+      onStateChange={onStateChange}
+    >
+      <Renderer
+        spec={spec}
+        registry={snapCatalogRegistry}
+        loading={loading}
+        fallback={fallback}
+      />
+      {children}
+    </JSONUIProvider>
+  );
+}