@farcaster/snap 2.8.0 → 2.10.0

package/dist/react-native/snap-view-core.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createStateStore } from "@json-render/react-native";
 import { snapJsonRenderCatalog } from "@farcaster/snap/ui";
 import { SnapCatalogView } from "./catalog-renderer.js";
 import { ConfettiOverlay } from "./confetti-overlay.js";
@@ -8,7 +9,7 @@ import { SnapVersionProvider } from "./snap-version-context.js";
 import { useCallback, useEffect, useMemo, useRef, useState, } from "react";
 import { ActivityIndicator, StyleSheet, View } from "react-native";
 import { DEFAULT_THEME_ACCENT, PALETTE_LIGHT_HEX, PALETTE_DARK_HEX, } from "@farcaster/snap";
-import { applyStatePaths, buildInitialRenderState, cloneSnapRenderState, getUnpresentedSnapEffects, markSnapEffectsPresented, } from "../render-state.js";
+import { buildActionActivityStateChanges, buildInitialRenderState, cloneSnapRenderState, getUnpresentedSnapEffects, hasPendingSnapAction, markSnapEffectsPresented, } from "../render-state.js";
 function asRecord(value) {
     return value && typeof value === "object"
         ? value
@@ -17,6 +18,11 @@ function asRecord(value) {
 function optionalString(value) {
     return value ? String(value) : undefined;
 }
+function recordValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
 function withDefaultElementProps(spec) {
     if (!spec || typeof spec !== "object" || !("elements" in spec))
         return spec;
@@ -54,10 +60,26 @@ export function SnapViewCoreInner({ snap, handlers, loading = false, loadingOver
         initialRenderState,
         themeAccent: snap.theme?.accent,
     }), [initialRenderState, spec.state, snap.theme?.accent]);
+    const stateStore = useMemo(() => createStateStore(initialState), [
+        initialState,
+    ]);
     const stateRef = useRef(initialState);
+    const onRenderStateChangeRef = useRef(onRenderStateChange);
+    const pendingActionCountRef = useRef(0);
+    const [hasPendingAction, setHasPendingAction] = useState(false);
+    const [actionActivityVersion, setActionActivityVersion] = useState(0);
     useEffect(() => {
         stateRef.current = cloneSnapRenderState(initialState);
     }, [initialState]);
+    useEffect(() => {
+        onRenderStateChangeRef.current = onRenderStateChange;
+    }, [onRenderStateChange]);
+    useEffect(() => stateStore.subscribe(() => {
+        const snapshot = cloneSnapRenderState(stateStore.getSnapshot());
+        stateRef.current = snapshot;
+        setHasPendingAction(hasPendingSnapAction(snapshot));
+        onRenderStateChangeRef.current?.(snapshot);
+    }), [stateStore]);
     useEffect(() => {
         const catalogResult = snapJsonRenderCatalog.validate(spec);
         if (!catalogResult.success) {
@@ -77,10 +99,6 @@ export function SnapViewCoreInner({ snap, handlers, loading = false, loadingOver
         confetti: 0,
         fireworks: 0,
     });
-    const onRenderStateChangeRef = useRef(onRenderStateChange);
-    useEffect(() => {
-        onRenderStateChangeRef.current = onRenderStateChange;
-    }, [onRenderStateChange]);
     useEffect(() => {
         const effectsToPresent = getUnpresentedSnapEffects(stateRef.current, snapEffects);
         if (effectsToPresent.length === 0) {
@@ -97,7 +115,10 @@ export function SnapViewCoreInner({ snap, handlers, loading = false, loadingOver
             return;
         }
         if (markSnapEffectsPresented(stateRef.current, effectsToPresent)) {
-            onRenderStateChangeRef.current?.(cloneSnapRenderState(stateRef.current));
+            const meta = recordValue(stateRef.current.__snapRender);
+            stateStore.update({
+                "/__snapRender/presentedEffects": meta?.presentedEffects ?? [],
+            });
         }
         setEffectRunKeys((current) => ({
             confetti: effectsToPresent.includes("confetti")
@@ -111,47 +132,70 @@ export function SnapViewCoreInner({ snap, handlers, loading = false, loadingOver
                     ? current.fireworks
                     : 0,
         }));
-    }, [initialState, showConfetti, showFireworks, snapEffects]);
+    }, [initialState, showConfetti, showFireworks, snapEffects, stateStore]);
     const handlersRef = useRef(handlers);
     handlersRef.current = handlers;
+    const applyActionActivityState = useCallback((name, params, pending) => {
+        stateStore.update(Object.fromEntries(buildActionActivityStateChanges({
+            actionName: name,
+            params,
+            pending,
+        }).map(({ path, value }) => [path, value])));
+    }, [stateStore]);
+    const setActionPending = useCallback((name, params) => {
+        pendingActionCountRef.current += 1;
+        setHasPendingAction(true);
+        setActionActivityVersion((version) => version + 1);
+        applyActionActivityState(name, params, true);
+    }, [applyActionActivityState]);
+    const setActionSettled = useCallback((name, params) => {
+        pendingActionCountRef.current = Math.max(0, pendingActionCountRef.current - 1);
+        applyActionActivityState(name, params, false);
+        if (pendingActionCountRef.current === 0) {
+            setHasPendingAction(false);
+        }
+        setActionActivityVersion((version) => version + 1);
+    }, [applyActionActivityState]);
     const handleAction = useCallback((name, params) => {
         const inputs = (stateRef.current.inputs ?? {});
         const p = (params ?? {});
         const h = handlersRef.current;
+        let result;
+        setActionPending(name, p);
         switch (name) {
             case "submit":
-                h.submit(String(p.target ?? ""), inputs);
+                result = h.submit(String(p.target ?? ""), inputs);
                 break;
             case "open_url":
-                h.open_url(String(p.target ?? ""));
+                result = h.open_url(String(p.target ?? ""));
                 break;
             case "open_snap":
-                h.open_snap(String(p.target ?? ""));
+                result = h.open_snap(String(p.target ?? ""));
                 break;
             case "open_mini_app":
-                h.open_mini_app(String(p.target ?? ""));
+                result = h.open_mini_app(String(p.target ?? ""));
                 break;
             case "view_cast":
-                h.view_cast({ hash: String(p.hash ?? "") });
+                result = h.view_cast({ hash: String(p.hash ?? "") });
                 break;
             case "view_profile":
-                h.view_profile({ fid: Number(p.fid ?? 0) });
+                result = h.view_profile({ fid: Number(p.fid ?? 0) });
                 break;
             case "view_channel":
-                h.view_channel({ channelKey: String(p.channelKey ?? "") });
+                result = h.view_channel({ channelKey: String(p.channelKey ?? "") });
                 break;
             case "compose_cast":
-                h.compose_cast({
+                result = h.compose_cast({
                     text: p.text ? String(p.text) : undefined,
                     channelKey: p.channelKey ? String(p.channelKey) : undefined,
                     embeds: Array.isArray(p.embeds) ? p.embeds : undefined,
                 });
                 break;
             case "view_token":
-                h.view_token({ token: String(p.token ?? "") });
+                result = h.view_token({ token: String(p.token ?? "") });
                 break;
             case "send_token":
-                h.send_token({
+                result = h.send_token({
                     token: String(p.token ?? ""),
                     amount: p.amount ? String(p.amount) : undefined,
                     recipientFid: p.recipientFid ? Number(p.recipientFid) : undefined,
@@ -161,13 +205,13 @@ export function SnapViewCoreInner({ snap, handlers, loading = false, loadingOver
                 });
                 break;
             case "swap_token":
-                h.swap_token({
+                result = h.swap_token({
                     sellToken: p.sellToken ? String(p.sellToken) : undefined,
                     buyToken: p.buyToken ? String(p.buyToken) : undefined,
                 });
                 break;
             case "send_transaction":
-                h.send_transaction?.({
+                result = h.send_transaction?.({
                     chainId: String(p.chainId ?? ""),
                     to: String(p.to ?? ""),
                     data: optionalString(p.data),
@@ -178,34 +222,23 @@ export function SnapViewCoreInner({ snap, handlers, loading = false, loadingOver
                     maxPriorityFeePerGas: optionalString(p.maxPriorityFeePerGas),
                 });
                 break;
-            case "send_calls":
-                h.send_calls?.({
-                    version: p.version === "1.0" ? "1.0" : undefined,
-                    chainId: String(p.chainId ?? ""),
-                    atomicRequired: typeof p.atomicRequired === "boolean"
-                        ? p.atomicRequired
-                        : undefined,
-                    id: optionalString(p.id),
-                    calls: Array.isArray(p.calls)
-                        ? p.calls.map((call) => {
-                            const c = asRecord(call);
-                            return {
-                                to: optionalString(c.to),
-                                data: optionalString(c.data),
-                                value: optionalString(c.value),
-                            };
-                        })
-                        : [],
-                });
-                break;
             default:
                 break;
         }
-    }, []);
-    return (_jsxs(View, { style: styles.container, children: [loading ? (loadingOverlay === undefined ? (_jsx(SnapLoadingOverlay, { appearance: mode, accentHex: accentHex })) : (loadingOverlay)) : null, _jsx(SnapVersionProvider, { value: snap.version === "2.0" ? "2.0" : "1.0", children: _jsx(SnapCatalogView, { spec: spec, state: initialState, loading: false, onStateChange: (changes) => {
-                        applyStatePaths(stateRef.current, changes);
-                        onRenderStateChange?.(cloneSnapRenderState(stateRef.current));
-                    }, onAction: handleAction }, pageKey) }), showConfetti && effectRunKeys.confetti > 0 && (_jsx(ConfettiOverlay, {}, effectRunKeys.confetti)), showFireworks && effectRunKeys.fireworks > 0 && (_jsx(FireworksOverlay, {}, effectRunKeys.fireworks))] }));
+        if (result instanceof Promise) {
+            void result.finally(() => {
+                setActionSettled(name, p);
+            }).catch(() => { });
+        }
+        else {
+            setActionSettled(name, p);
+        }
+        return result;
+    }, [setActionPending, setActionSettled]);
+    const showLoadingOverlay = loading ||
+        hasPendingAction ||
+        (actionActivityVersion >= 0 && pendingActionCountRef.current > 0);
+    return (_jsxs(View, { style: styles.container, onStartShouldSetResponderCapture: () => hasPendingSnapAction(stateRef.current), children: [showLoadingOverlay ? (loadingOverlay === undefined ? (_jsx(SnapLoadingOverlay, { appearance: mode, accentHex: accentHex })) : (loadingOverlay)) : null, _jsx(SnapVersionProvider, { value: snap.version === "2.0" ? "2.0" : "1.0", children: _jsx(SnapCatalogView, { spec: spec, store: stateStore, loading: false, onAction: handleAction }, pageKey) }), showConfetti && effectRunKeys.confetti > 0 && (_jsx(ConfettiOverlay, {}, effectRunKeys.confetti)), showFireworks && effectRunKeys.fireworks > 0 && (_jsx(FireworksOverlay, {}, effectRunKeys.fireworks))] }));
 }
 export function SnapLoadingOverlay({ appearance, accentHex, }) {
     return (_jsx(View, { style: [

package/dist/react-native/types.d.ts

@@ -1,5 +1,6 @@
 import type { Spec } from "@json-render/core";
 import type { SnapRenderState } from "../render-state.js";
+import type { SnapTransactionResult } from "../schemas.js";
 export type { SnapRenderState };
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
@@ -22,17 +23,6 @@ export type SnapSendTransactionParams = {
     maxFeePerGas?: string;
     maxPriorityFeePerGas?: string;
 };
-export type SnapSendCallsParams = {
-    version?: "1.0";
-    chainId: string;
-    atomicRequired?: boolean;
-    id?: string;
-    calls: Array<{
-        to?: string;
-        data?: string;
-        value?: string;
-    }>;
-};
 export type SnapActionHandlers = {
     submit: (target: string, inputs: Record<string, JsonValue>) => void;
     open_url: (target: string) => void;
@@ -65,6 +55,5 @@ export type SnapActionHandlers = {
         sellToken?: string;
         buyToken?: string;
     }) => void;
-    send_transaction?: (params: SnapSendTransactionParams) => void;
-    send_calls?: (params: SnapSendCallsParams) => void;
+    send_transaction?: (params: SnapSendTransactionParams) => void | Promise<void | SnapTransactionResult>;
 };

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(),
 });