solid-drift 0.16.0 → 0.17.0

package/README.md

@@ -1094,6 +1094,41 @@ const connect = createConnectButton(() => btn, { strength: 0.35 });
 
 Returns `{ copyTick, chainPulse, status }`. `status()` is `"idle"`, `"ticking"` (check visible), or `"pulsing"` (ring expanding). Call `chainPulse()` after a successful connection or network switch. Under reduced motion there is no magnetic pull or scale; `copyTick()` and `chainPulse()` still show their overlays statically.
 
+### `createAgentTx(options?)`
+
+AI proposes, the user approves, the transaction executes. The agent (an LLM) calls `propose()` with a plain-data proposal the user can read (`to`, `value`, `data`, `description`, `chainId`); the user calls `approve()` or `reject()`; `execute()` hands the approved proposal to your wallet adapter and the inner `createTxLifecycle` tracks signing to confirmation. The library never signs: `execute` is your wagmi/viem send function.
+
+States flow `idle` to `proposed` to `approved` to `executing` to `confirmed`, with `rejected` and `failed` as the off-ramps. Invalid transitions are no-ops, so an LLM-driven UI cannot skip the user's approval. `progress()` is spring-smoothed across the whole flow for progress UI, and `tx` exposes the inner lifecycle for manual driving or extra rendering.
+
+```tsx
+const agentTx = createAgentTx({
+  execute: async (p) => sendTransaction({ to: p.to, value: p.value }),
+  source: () => receiptQuery(), // wagmi/viem-style status
+});
+// The AI proposes:
+agentTx.propose({
+  to: "0x…",
+  value: "1000000000000000000",
+  description: "Swap 1 ETH for USDC at the current rate.",
+});
+// The user reviews agentTx.proposal() and taps approve:
+agentTx.approve();
+await agentTx.execute(); // "executing" to "confirmed"
+```
+
+DriftSpec gains two LLM-generatable web3 steps for full dApp choreography: `"agentTx"` (options `to`, `description`, `value`, `data`, `chainId`, `autoApprove`) proposes a transaction mid-spec and waits for the host, via the new `createSpecPlayer(spec, refs, hooks)` third parameter, to approve and execute it through `hooks.onAgentTxStep`; `"txReceipt"` (options `hash`, `endpoint`, `timeout`) waits for a transaction hash to mine. A typical generated ceremony reads: `streamReveal` (explain) to `agentTx` (approve and send) to `txReceipt` (confirm).
+
+```json
+{
+  "version": 1,
+  "scenes": [
+    { "primitive": "streamReveal", "target": "explainer", "options": { "text": "The agent proposes swapping 1 ETH for USDC." } },
+    { "primitive": "agentTx", "options": { "to": "0x…", "description": "Swap 1 ETH for USDC.", "value": "1000000000000000000" } },
+    { "primitive": "txReceipt", "options": { "hash": "0x…" } }
+  ]
+}
+```
+
 ### Web3 data layer
 
 A zero-dependency read layer for chain and market data as signals: public RPC and API endpoints over `fetch`, with user-swappable endpoints. Every network primitive shares the `{ data, error, status, retry, abort }` shape, is SSR-safe (nothing fetches on the server), and polls with error backoff. Defaults are conservative because public endpoints are rate-limited. This is read-only: transaction signing stays with wallet libraries.

package/dist/ai.d.ts

@@ -15,6 +15,9 @@
 import { type Accessor } from "solid-js";
 import { type Easing, type EasingName } from "./easing.js";
 import { type KineticTypeFrom } from "./motion.js";
+import { type AgentTxControls, type AgentTxProposal } from "./web3.js";
+/** Re-exported for `SpecPlayerHooks` consumers. */
+export type { AgentTxProposal, AgentTxControls };
 type MaybeElement = () => Element | null | undefined;
 export type StreamRevealStatus = "idle" | "streaming" | "done";
 export interface StreamRevealOptions {
@@ -125,7 +128,7 @@ export interface AgentStateControls {
  */
 export declare function createAgentState(options?: AgentStateOptions): AgentStateControls;
 /** Primitives a drift spec can choreograph. */
-export type DriftSpecPrimitive = "kineticType" | "camera" | "colorShift" | "transition" | "beat" | "streamReveal";
+export type DriftSpecPrimitive = "kineticType" | "camera" | "colorShift" | "transition" | "beat" | "streamReveal" | "agentTx" | "txReceipt";
 /** One choreographed step. */
 export interface DriftSpecStep {
     /** Which primitive renders this step. */
@@ -139,7 +142,9 @@ export interface DriftSpecStep {
     /**
      * Primitive options. Validated against each primitive's minimal
      * shape. "camera" reads `keyframes`, "colorShift" reads `stops`,
-     * "streamReveal" reads `text` here.
+     * "streamReveal" reads `text`, "agentTx" reads `to`, `description`,
+     * `value`, `data`, `chainId` and `autoApprove`, "txReceipt" reads
+     * `hash`, `endpoint` and `timeout`.
      */
     options?: Record<string, unknown>;
     /** Step budget in milliseconds, for timed players. */
@@ -185,10 +190,23 @@ export interface SpecPlayerControls {
     /** Current scene index, or -1 before the first play(). */
     scene: Accessor<number>;
 }
+/** Host hooks for spec steps that need the outside world. */
+export interface SpecPlayerHooks {
+    /**
+     * Called when an "agentTx" step proposes its transaction. Show your
+     * approval UI here and call `tx.approve()` / `tx.reject()` (then
+     * `tx.execute()`) on the controls. The step waits for a terminal
+     * state ("confirmed", "rejected", "failed"); `stop()` skips it.
+     */
+    onAgentTxStep?: (proposal: AgentTxProposal, tx: AgentTxControls) => void;
+}
 /**
  * Render a validated DriftSpec: each scene's primitive plays in
  * order against the element refs the host supplies. `duration` on a
- * step caps that step's budget.
+ * step caps that step's budget. Web3 steps ("agentTx", "txReceipt")
+ * choreograph on-chain actions: "agentTx" proposes a transaction and
+ * waits for the host (via `hooks.onAgentTxStep`) to approve and
+ * execute it; "txReceipt" waits for a transaction hash to mine.
  *
  * SSR-safe: `play()` is a no-op on the server. Under reduced motion
  * `play()` jumps straight to the last scene (the clean final frame),
@@ -203,5 +221,4 @@ export interface SpecPlayerControls {
  * await player.play()
  * ```
  */
-export declare function createSpecPlayer(spec: DriftSpec, refs: Record<string, MaybeElement>): SpecPlayerControls;
-export {};
+export declare function createSpecPlayer(spec: DriftSpec, refs: Record<string, MaybeElement>, hooks?: SpecPlayerHooks): SpecPlayerControls;

package/dist/ai.js

@@ -19,6 +19,9 @@ import { now, schedule } from "./engine.js";
 import { createBeat, createCamera, createColorShift, createKineticType, createTransition, } from "./motion.js";
 import { prefersReducedMotion } from "./reduced-motion.js";
 import { appendUnits } from "./text.js";
+import { createAgentTx, } from "./web3.js";
+import { createTxReceipt } from "./web3data.js";
+import { isAddress } from "./web3data.js";
 function clamp01(v) {
     return v < 0 ? 0 : v > 1 ? 1 : v;
 }
@@ -258,6 +261,8 @@ const PRIMITIVES = [
     "transition",
     "beat",
     "streamReveal",
+    "agentTx",
+    "txReceipt",
 ];
 /** Primitives that render into an element and need a target key. */
 const DOM_PRIMITIVES = [
@@ -316,6 +321,41 @@ function checkOptions(primitive, options, base) {
                 throw new DriftSpecError(at("text"), "expected a string");
             }
             break;
+        case "agentTx":
+            if (typeof options.to !== "string" || !isAddress(options.to)) {
+                throw new DriftSpecError(at("to"), "expected a valid 0x address");
+            }
+            if (typeof options.description !== "string" ||
+                options.description.length === 0) {
+                throw new DriftSpecError(at("description"), "expected a non-empty string");
+            }
+            if (options.value !== undefined && typeof options.value !== "string") {
+                throw new DriftSpecError(at("value"), "expected a string");
+            }
+            if (options.data !== undefined && typeof options.data !== "string") {
+                throw new DriftSpecError(at("data"), "expected a string");
+            }
+            if (options.chainId !== undefined) {
+                assertPositiveNumber(options.chainId, at("chainId"));
+            }
+            if (options.autoApprove !== undefined &&
+                typeof options.autoApprove !== "boolean") {
+                throw new DriftSpecError(at("autoApprove"), "expected a boolean");
+            }
+            break;
+        case "txReceipt":
+            if (typeof options.hash !== "string" ||
+                !/^0x[0-9a-fA-F]{64}$/.test(options.hash)) {
+                throw new DriftSpecError(at("hash"), "expected a 0x transaction hash");
+            }
+            if (options.endpoint !== undefined &&
+                typeof options.endpoint !== "string") {
+                throw new DriftSpecError(at("endpoint"), "expected a string");
+            }
+            if (options.timeout !== undefined) {
+                assertPositiveNumber(options.timeout, at("timeout"));
+            }
+            break;
     }
 }
 /**
@@ -478,11 +518,74 @@ const stepPlayers = {
         };
         return { promise: timer.finished.then(() => c.stop()), stop: stopAll };
     },
+    agentTx: (_target, options, _budget, hooks) => {
+        const tx = createAgentTx();
+        const proposal = {
+            to: options.to,
+            description: options.description,
+        };
+        if (typeof options.value === "string")
+            proposal.value = options.value;
+        if (typeof options.data === "string")
+            proposal.data = options.data;
+        if (typeof options.chainId === "number") {
+            proposal.chainId = options.chainId;
+        }
+        tx.propose(proposal);
+        hooks?.onAgentTxStep?.(proposal, tx);
+        if (options.autoApprove === true)
+            tx.approve();
+        // The host approves through the hook; the step ends at a terminal
+        // state. Without a host the step simply waits until stop() skips it.
+        return whenDone(() => {
+            const s = tx.state();
+            return s === "confirmed" || s === "rejected" || s === "failed";
+        });
+    },
+    txReceipt: (_target, options) => {
+        const watcher = createTxReceipt(options.hash, {
+            endpoint: typeof options.endpoint === "string" ? options.endpoint : undefined,
+            interval: 4000,
+        });
+        const timeout = typeof options.timeout === "number" ? options.timeout : 120000;
+        let cancel = null;
+        let resolveFn;
+        const started = Date.now();
+        const promise = new Promise((resolve) => {
+            resolveFn = resolve;
+            if (watcher.mined()) {
+                resolve();
+                return;
+            }
+            cancel = schedule(() => {
+                if (watcher.mined() || Date.now() - started >= timeout) {
+                    resolve();
+                    return false;
+                }
+                return true;
+            });
+        });
+        const done = () => {
+            cancel?.();
+            cancel = null;
+            watcher.abort();
+        };
+        return {
+            promise: promise.then(done),
+            stop: () => {
+                done();
+                resolveFn();
+            },
+        };
+    },
 };
 /**
  * Render a validated DriftSpec: each scene's primitive plays in
  * order against the element refs the host supplies. `duration` on a
- * step caps that step's budget.
+ * step caps that step's budget. Web3 steps ("agentTx", "txReceipt")
+ * choreograph on-chain actions: "agentTx" proposes a transaction and
+ * waits for the host (via `hooks.onAgentTxStep`) to approve and
+ * execute it; "txReceipt" waits for a transaction hash to mine.
  *
  * SSR-safe: `play()` is a no-op on the server. Under reduced motion
  * `play()` jumps straight to the last scene (the clean final frame),
@@ -497,7 +600,7 @@ const stepPlayers = {
  * await player.play()
  * ```
  */
-export function createSpecPlayer(spec, refs) {
+export function createSpecPlayer(spec, refs, hooks) {
     const [status, setStatus] = createSignal("idle");
     const [scene, setScene] = createSignal(-1);
     let currentStop = null;
@@ -505,7 +608,7 @@ export function createSpecPlayer(spec, refs) {
     let stopped = false;
     const runStep = async (step) => {
         const target = step.target === undefined ? undefined : refs[step.target];
-        const handle = stepPlayers[step.primitive](target, step.options ?? {}, step.duration);
+        const handle = stepPlayers[step.primitive](target, step.options ?? {}, step.duration, hooks);
         currentStop = handle.stop;
         if (step.duration === undefined) {
             await handle.promise;

package/dist/index.d.ts

@@ -31,8 +31,8 @@ export { createKineticType, createScenePlayer, createShowreel, createCamera, cre
 export type { KineticTypeFrom, KineticTypeOptions, KineticTypeStatus, KineticTypeControls, MotionScene, ScenePlayerStatus, ScenePlayerControls, ShowreelScene, ShowreelSceneKind, CameraKeyframe, CameraOptions, ColorShiftOptions, ColorShiftStatus, ColorShiftControls, TransitionType, TransitionDirection, TransitionOptions, TransitionLayerStyle, TransitionStatus, TransitionControls, BeatOptions, BeatStatus, BeatControls, BeatCutOptions, } from "./motion.js";
 export { createDrag, type DragStatus, type DragAxis, type DragConstraints, type DragEndInfo, type DragOptions, type DragControls, } from "./gesture.js";
 export { createStreamReveal, createAgentState, parseDriftSpec, createSpecPlayer, DriftSpecError, } from "./ai.js";
-export type { StreamRevealStatus, StreamRevealOptions, StreamRevealControls, AgentState, AgentStateTransition, AgentStateOptions, AgentStateControls, DriftSpecPrimitive, DriftSpecStep, DriftSpec, SpecPlayerStatus, SpecPlayerControls, } from "./ai.js";
-export { createTxLifecycle, createTicker, createMintReveal, createConnectButton, } from "./web3.js";
-export type { TxState, TxStatusInput, TxLifecycleOptions, TxLifecycleControls, TickerOptions, TickerControls, MintRevealStatus, MintRevealOptions, MintRevealControls, ConnectButtonOptions, ConnectButtonStatus, ConnectButtonControls, } from "./web3.js";
+export type { StreamRevealStatus, StreamRevealOptions, StreamRevealControls, AgentState, AgentStateTransition, AgentStateOptions, AgentStateControls, DriftSpecPrimitive, DriftSpecStep, DriftSpec, SpecPlayerStatus, SpecPlayerHooks, SpecPlayerControls, } from "./ai.js";
+export { createTxLifecycle, createTicker, createMintReveal, createConnectButton, createAgentTx, } from "./web3.js";
+export type { TxState, TxStatusInput, TxLifecycleOptions, TxLifecycleControls, TickerOptions, TickerControls, MintRevealStatus, MintRevealOptions, MintRevealControls, ConnectButtonOptions, ConnectButtonStatus, ConnectButtonControls, AgentTxState, AgentTxProposal, AgentTxOptions, AgentTxControls, } from "./web3.js";
 export { createPoll, shortenAddress, isAddress, formatUnits, parseUnits, CHAINS, createChain, createTokenPrice, createPriceChange, createPriceCompare, createGasPrice, createBalance, createTxReceipt, createBlockNumber, createChainlinkPrice, createNFTMetadata, createENS, createIdenticon, } from "./web3data.js";
 export type { PollStatus, PollOptions, PollControls, ChainInfo, TokenPrice, TokenPriceOptions, PriceChangeOptions, GasPriceOptions, GasPriceData, BalanceOptions, BalanceData, TxReceiptData, TxReceiptOptions, BlockNumberOptions, ChainlinkPriceOptions, NFTMetadata, NFTMetadataOptions, ENSOptions, IdenticonOptions, } from "./web3data.js";

package/dist/index.js

@@ -30,5 +30,5 @@ export { easings, cubicBezier, linear, easeInQuad, easeOutQuad, easeInOutQuad, e
 export { createKineticType, createScenePlayer, createShowreel, createCamera, createColorShift, createTransition, createBeat, createBeatCuts, } from "./motion.js";
 export { createDrag, } from "./gesture.js";
 export { createStreamReveal, createAgentState, parseDriftSpec, createSpecPlayer, DriftSpecError, } from "./ai.js";
-export { createTxLifecycle, createTicker, createMintReveal, createConnectButton, } from "./web3.js";
+export { createTxLifecycle, createTicker, createMintReveal, createConnectButton, createAgentTx, } from "./web3.js";
 export { createPoll, shortenAddress, isAddress, formatUnits, parseUnits, CHAINS, createChain, createTokenPrice, createPriceChange, createPriceCompare, createGasPrice, createBalance, createTxReceipt, createBlockNumber, createChainlinkPrice, createNFTMetadata, createENS, createIdenticon, } from "./web3data.js";

package/dist/web3.d.ts

@@ -82,6 +82,104 @@ export interface TxLifecycleControls {
  * changes apply instantly and `progress()` jumps to its target.
  */
 export declare function createTxLifecycle(options?: TxLifecycleOptions): TxLifecycleControls;
+/**
+ * Stages of an AI-proposed transaction: the agent proposes, the user
+ * approves or rejects, the transaction executes.
+ */
+export type AgentTxState = "idle" | "proposed" | "approved" | "executing" | "confirmed" | "rejected" | "failed";
+/** An AI-proposed on-chain action, in plain data the user can review. */
+export interface AgentTxProposal {
+    /** Destination address. */
+    to: string;
+    /** Wei value as a decimal string. Default "0". */
+    value?: string;
+    /** Hex calldata. */
+    data?: string;
+    /** The AI's plain-language explanation of what this does. */
+    description: string;
+    /** Chain id. Default 1. */
+    chainId?: number;
+}
+export interface AgentTxOptions {
+    /**
+     * Executes the approved proposal against the wallet/chain adapter
+     * and resolves with the transaction hash. Throw to fail. Omit to
+     * drive the inner lifecycle manually through `tx`.
+     */
+    execute?: (proposal: AgentTxProposal, signal: AbortSignal) => Promise<string>;
+    /** wagmi/viem-style status accessor, fed to the inner lifecycle. */
+    source?: Accessor<TxStatusInput>;
+    /** Confirmations that promote "pending" to "confirming". Default 1. */
+    requiredConfirmations?: number;
+    /** Spring stiffness for the progress value. Default 170. */
+    stiffness?: number;
+    /** Spring damping for the progress value. Default 26. */
+    damping?: number;
+    /** Called after entering a state, with the previous state. */
+    onEnter?: (state: AgentTxState, prev: AgentTxState) => void;
+}
+export interface AgentTxControls {
+    /** Current agent-tx state. */
+    state: Accessor<AgentTxState>;
+    /** The proposal under review, if any. */
+    proposal: Accessor<AgentTxProposal | undefined>;
+    /**
+     * Inner transaction lifecycle, live during "executing". Feed it
+     * through `source` or drive it manually with `tx.set()`.
+     */
+    tx: TxLifecycleControls;
+    /** Propose a transaction for the user to review. */
+    propose: (proposal: AgentTxProposal) => void;
+    /** Approve the proposal; only from "proposed". */
+    approve: () => void;
+    /** Reject the proposal; only from "proposed". */
+    reject: () => void;
+    /**
+     * Run the approved proposal: calls `execute`, then tracks the inner
+     * lifecycle to "confirmed" or "failed". Only from "approved".
+     */
+    execute: () => Promise<void>;
+    /** Back to "idle", aborting any in-flight execution. */
+    reset: () => void;
+    /**
+     * 0 to 1 across the whole flow, spring-smoothed for progress UI:
+     * idle 0, proposed 0.2, approved 0.35, executing 0.65,
+     * confirmed/failed 1, rejected back to 0.
+     */
+    progress: Accessor<number>;
+}
+/**
+ * AI proposes, the user approves, the transaction executes.
+ *
+ * The agent (an LLM) calls `propose()` with a plain-data proposal the
+ * user can read; the user calls `approve()` or `reject()`; `execute()`
+ * hands the approved proposal to the wallet adapter and the inner
+ * `createTxLifecycle` tracks signing to confirmation. The library
+ * never signs: `execute` is your wagmi/viem send function.
+ *
+ * ```ts
+ * const agentTx = createAgentTx({
+ *   execute: async (p) => sendTransaction({
+ *     to: p.to, value: p.value, data: p.data,
+ *   }),
+ *   source: () => receiptQuery(),
+ * })
+ * // The AI proposes:
+ * agentTx.propose({
+ *   to: "0x…",
+ *   value: "1000000000000000000",
+ *   description: "Swap 1 ETH for USDC at the current rate.",
+ * })
+ * // The user reviews proposal() and taps approve:
+ * agentTx.approve()
+ * await agentTx.execute() // "executing" to "confirmed"
+ * ```
+ *
+ * Invalid transitions are no-ops, so LLM-driven UIs cannot skip the
+ * user's approval. SSR-safe. Under reduced motion `progress()` jumps
+ * to its target.
+ */
+export declare function createAgentTx(options?: AgentTxOptions): AgentTxControls;
 export interface TickerOptions {
     /** Decimals in the formatted output. Default 2. */
     decimals?: number;

package/dist/web3.js

@@ -20,6 +20,7 @@ import { createMagnetic } from "./pointer.js";
 import { prefersReducedMotion } from "./reduced-motion.js";
 import { createSpring } from "./spring.js";
 import { ownerDoc } from "./text.js";
+import { isAddress } from "./web3data.js";
 function clamp01(v) {
     return v < 0 ? 0 : v > 1 ? 1 : v;
 }
@@ -103,6 +104,143 @@ export function createTxLifecycle(options = {}) {
         progress,
     };
 }
+const AGENT_TX_PROGRESS = {
+    idle: 0,
+    proposed: 0.2,
+    approved: 0.35,
+    executing: 0.65,
+    confirmed: 1,
+    rejected: 0,
+    failed: 1,
+};
+/**
+ * AI proposes, the user approves, the transaction executes.
+ *
+ * The agent (an LLM) calls `propose()` with a plain-data proposal the
+ * user can read; the user calls `approve()` or `reject()`; `execute()`
+ * hands the approved proposal to the wallet adapter and the inner
+ * `createTxLifecycle` tracks signing to confirmation. The library
+ * never signs: `execute` is your wagmi/viem send function.
+ *
+ * ```ts
+ * const agentTx = createAgentTx({
+ *   execute: async (p) => sendTransaction({
+ *     to: p.to, value: p.value, data: p.data,
+ *   }),
+ *   source: () => receiptQuery(),
+ * })
+ * // The AI proposes:
+ * agentTx.propose({
+ *   to: "0x…",
+ *   value: "1000000000000000000",
+ *   description: "Swap 1 ETH for USDC at the current rate.",
+ * })
+ * // The user reviews proposal() and taps approve:
+ * agentTx.approve()
+ * await agentTx.execute() // "executing" to "confirmed"
+ * ```
+ *
+ * Invalid transitions are no-ops, so LLM-driven UIs cannot skip the
+ * user's approval. SSR-safe. Under reduced motion `progress()` jumps
+ * to its target.
+ */
+export function createAgentTx(options = {}) {
+    const { execute, source, requiredConfirmations = 1, stiffness = 170, damping = 26, onEnter, } = options;
+    const [state, setState] = createSignal("idle");
+    const [proposal, setProposal] = createSignal(undefined);
+    const [target, setTarget] = createSignal(0);
+    const progress = createSpring(target, { stiffness, damping });
+    const tx = createTxLifecycle({
+        source,
+        requiredConfirmations,
+        stiffness,
+        damping,
+    });
+    let execAborter = null;
+    const apply = (next) => {
+        const current = state();
+        if (next === current)
+            return;
+        setState(next);
+        setTarget(AGENT_TX_PROGRESS[next]);
+        onEnter?.(next, current);
+    };
+    // Mirror the inner lifecycle into the agent flow.
+    createEffect(() => {
+        const inner = tx.state();
+        if (state() !== "executing")
+            return;
+        if (inner === "success")
+            apply("confirmed");
+        else if (inner === "failed")
+            apply("failed");
+    });
+    const propose = (p) => {
+        const s = state();
+        if (s !== "idle" && s !== "rejected" && s !== "failed" && s !== "confirmed") {
+            return;
+        }
+        if (!isAddress(p.to)) {
+            throw new Error("createAgentTx: proposal 'to' is not a valid address.");
+        }
+        if (!p.description) {
+            throw new Error("createAgentTx: proposal needs a description.");
+        }
+        setProposal(p);
+        apply("proposed");
+    };
+    const approve = () => {
+        if (state() === "proposed")
+            apply("approved");
+    };
+    const reject = () => {
+        if (state() === "proposed")
+            apply("rejected");
+    };
+    const runExecute = async () => {
+        if (state() !== "approved")
+            return;
+        const p = proposal();
+        if (!p)
+            return;
+        apply("executing");
+        tx.set("signing");
+        // Without an execute function the host drives tx manually.
+        if (!execute)
+            return;
+        execAborter?.abort();
+        execAborter = new AbortController();
+        const signal = execAborter.signal;
+        try {
+            await execute(p, signal);
+            if (!signal.aborted)
+                tx.set("pending");
+        }
+        catch {
+            if (!signal.aborted)
+                tx.set("failed");
+        }
+    };
+    const reset = () => {
+        execAborter?.abort();
+        execAborter = null;
+        setProposal(undefined);
+        tx.reset();
+        apply("idle");
+    };
+    onCleanup(() => execAborter?.abort());
+    return {
+        state,
+        proposal,
+        tx,
+        propose,
+        approve,
+        reject,
+        execute: runExecute,
+        reset,
+        progress,
+    };
+}
 /**
  * Animated price/balance ticker: per-digit roll, direction flash.
  *

package/package.json

@@ -43,5 +43,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.16.0"
+  "version": "0.17.0"
 }