@chipi-stack/chipi-react 14.3.1 → 14.6.0

package/dist/index.d.mts

@@ -1,10 +1,10 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
-import { ChipiSDK } from '@chipi-stack/backend';
+import React, { ReactNode } from 'react';
+import { ChipiSDK, NewOwnerInput } from '@chipi-stack/backend';
 import { ChipiSDKConfig } from '@chipi-stack/types';
 export * from '@chipi-stack/types';
 export { Chain, ChainToken } from '@chipi-stack/types';
-export { ChipiWalletData, SessionState, SessionWallet, UseChipiSessionConfig, UseChipiSessionReturn, UseChipiWalletConfig, UseChipiWalletReturn, UseTransferConfig, UseX402PaymentConfig, UseX402PaymentReturn, useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuPurchase, useGetTokenBalance, useGetTransaction, useGetTransactionList, useGetTransactionStatus, useGetWallet, useMigrateWalletToPasskey, usePurchaseSku, useRecordSendTransaction, useRevokeSessionKey, useSyncOnChainTransfers, useTransfer, useUpdateWalletEncryption, useX402Payment } from './hooks.mjs';
+export { ChipiWalletData, SessionState, SessionWallet, ThresholdSignState, UseChipiSessionConfig, UseChipiSessionReturn, UseChipiWalletConfig, UseChipiWalletReturn, UseGuardianRecoveryReturn, UseShhhSignerReturn, UseThresholdSignOptions, UseThresholdSignReturn, UseTransferConfig, UseX402PaymentConfig, UseX402PaymentReturn, useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuPurchase, useGetTokenBalance, useGetTransaction, useGetTransactionList, useGetTransactionStatus, useGetWallet, useGuardianRecovery, useMigrateWalletToPasskey, useMigrateWalletToShhh, usePurchaseSku, useRecordSendTransaction, useRevokeSessionKey, useShhhSigner, useSyncOnChainTransfers, useThresholdSign, useTransfer, useUpdateWalletEncryption, useX402Payment } from './hooks.mjs';
 import '@tanstack/react-query';
 
 interface PasskeyAdapter {
@@ -31,4 +31,78 @@ declare function ChipiProvider({ children, config, passkeyAdapter }: ChipiProvid
  */
 declare function useChipiContext(): ChipiContextValue;
 
-export { ChipiProvider, type PasskeyAdapter, useChipiContext };
+/**
+ * SHHH V8.4 standalone recovery component (Wave B B6.2).
+ *
+ * Controlled + headless: chipi-react owns the phase state machine and
+ * renders semantic HTML with `data-chipi-recover-*` attributes for CSS
+ * targeting. The integrator brings styling and supplies the side-effect
+ * callbacks (sign + execute against the paymaster). The component does
+ * NOT read chain state; the caller passes `pendingOp` from their own
+ * chain-read transport (multicall / view selectors / indexer).
+ *
+ * Two flows:
+ *
+ *   mode="add-device"        propose_add_owner   (48h)  execute_add_owner
+ *   mode="guardian-recovery" initiate_recovery   (7d)   finalize_recovery
+ *
+ * The wallet-connect ceremony that produces the new owner's pubkey
+ * (MetaMask connect, passkey enrollment, Apple Sign In) is intentionally
+ * out of scope: caller computes `newOwner` upstream and passes it in.
+ */
+interface RecoverProps {
+    /** Which flow this component renders. */
+    mode: "add-device" | "guardian-recovery";
+    /** The SHHH wallet being modified. */
+    walletAddress: bigint | string;
+    /**
+     * The new owner to add (or rotate the wallet to). Caller computes
+     * this upstream from whichever wallet-connect ceremony they ran.
+     */
+    newOwner: NewOwnerInput;
+    /**
+     * Pending op state read from chain by the caller. `null` (or omitted)
+     * means no op in flight; the propose form is shown. When set, the
+     * component switches to the countdown / execute panel.
+     */
+    pendingOp?: {
+        opId: bigint | string;
+        /** UNIX seconds when the op becomes executable. */
+        validAfter: number | bigint;
+    } | null;
+    /**
+     * Submits the propose (add-device) or initiate (guardian-recovery)
+     * OE through whatever paymaster / sign path the integrator wires.
+     * Returns the resulting opId + validAfter so the component can
+     * transition to "awaiting timelock" without waiting for the next
+     * chain read.
+     */
+    onPropose: () => Promise<{
+        opId: bigint | string;
+        validAfter: number | bigint;
+    }>;
+    /**
+     * Submits the execute (add-device) or finalize (guardian-recovery)
+     * OE once the timelock has elapsed.
+     */
+    onExecute: (opId: bigint | string) => Promise<void>;
+    /**
+     * Optional cancel handler. When omitted the cancel button is hidden.
+     * Add-device uses `cancel_pending_op` (any owner); guardian-recovery
+     * uses `cancel_recovery` (the original owner, if they resurface).
+     */
+    onCancel?: (opId: bigint | string) => Promise<void>;
+    /**
+     * Optional className for the root element. Compose with the
+     * `data-chipi-recover-*` selectors for styling.
+     */
+    className?: string;
+    /**
+     * Clock override for tests / chain-time logic. Defaults to
+     * `Math.floor(Date.now() / 1000)`.
+     */
+    nowSecs?: number;
+}
+declare function Recover(props: RecoverProps): React.ReactElement;
+
+export { ChipiProvider, type PasskeyAdapter, Recover, type RecoverProps, useChipiContext };

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
-import { ChipiSDK } from '@chipi-stack/backend';
+import React, { ReactNode } from 'react';
+import { ChipiSDK, NewOwnerInput } from '@chipi-stack/backend';
 import { ChipiSDKConfig } from '@chipi-stack/types';
 export * from '@chipi-stack/types';
 export { Chain, ChainToken } from '@chipi-stack/types';
-export { ChipiWalletData, SessionState, SessionWallet, UseChipiSessionConfig, UseChipiSessionReturn, UseChipiWalletConfig, UseChipiWalletReturn, UseTransferConfig, UseX402PaymentConfig, UseX402PaymentReturn, useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuPurchase, useGetTokenBalance, useGetTransaction, useGetTransactionList, useGetTransactionStatus, useGetWallet, useMigrateWalletToPasskey, usePurchaseSku, useRecordSendTransaction, useRevokeSessionKey, useSyncOnChainTransfers, useTransfer, useUpdateWalletEncryption, useX402Payment } from './hooks.js';
+export { ChipiWalletData, SessionState, SessionWallet, ThresholdSignState, UseChipiSessionConfig, UseChipiSessionReturn, UseChipiWalletConfig, UseChipiWalletReturn, UseGuardianRecoveryReturn, UseShhhSignerReturn, UseThresholdSignOptions, UseThresholdSignReturn, UseTransferConfig, UseX402PaymentConfig, UseX402PaymentReturn, useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuPurchase, useGetTokenBalance, useGetTransaction, useGetTransactionList, useGetTransactionStatus, useGetWallet, useGuardianRecovery, useMigrateWalletToPasskey, useMigrateWalletToShhh, usePurchaseSku, useRecordSendTransaction, useRevokeSessionKey, useShhhSigner, useSyncOnChainTransfers, useThresholdSign, useTransfer, useUpdateWalletEncryption, useX402Payment } from './hooks.js';
 import '@tanstack/react-query';
 
 interface PasskeyAdapter {
@@ -31,4 +31,78 @@ declare function ChipiProvider({ children, config, passkeyAdapter }: ChipiProvid
  */
 declare function useChipiContext(): ChipiContextValue;
 
-export { ChipiProvider, type PasskeyAdapter, useChipiContext };
+/**
+ * SHHH V8.4 standalone recovery component (Wave B B6.2).
+ *
+ * Controlled + headless: chipi-react owns the phase state machine and
+ * renders semantic HTML with `data-chipi-recover-*` attributes for CSS
+ * targeting. The integrator brings styling and supplies the side-effect
+ * callbacks (sign + execute against the paymaster). The component does
+ * NOT read chain state; the caller passes `pendingOp` from their own
+ * chain-read transport (multicall / view selectors / indexer).
+ *
+ * Two flows:
+ *
+ *   mode="add-device"        propose_add_owner   (48h)  execute_add_owner
+ *   mode="guardian-recovery" initiate_recovery   (7d)   finalize_recovery
+ *
+ * The wallet-connect ceremony that produces the new owner's pubkey
+ * (MetaMask connect, passkey enrollment, Apple Sign In) is intentionally
+ * out of scope: caller computes `newOwner` upstream and passes it in.
+ */
+interface RecoverProps {
+    /** Which flow this component renders. */
+    mode: "add-device" | "guardian-recovery";
+    /** The SHHH wallet being modified. */
+    walletAddress: bigint | string;
+    /**
+     * The new owner to add (or rotate the wallet to). Caller computes
+     * this upstream from whichever wallet-connect ceremony they ran.
+     */
+    newOwner: NewOwnerInput;
+    /**
+     * Pending op state read from chain by the caller. `null` (or omitted)
+     * means no op in flight; the propose form is shown. When set, the
+     * component switches to the countdown / execute panel.
+     */
+    pendingOp?: {
+        opId: bigint | string;
+        /** UNIX seconds when the op becomes executable. */
+        validAfter: number | bigint;
+    } | null;
+    /**
+     * Submits the propose (add-device) or initiate (guardian-recovery)
+     * OE through whatever paymaster / sign path the integrator wires.
+     * Returns the resulting opId + validAfter so the component can
+     * transition to "awaiting timelock" without waiting for the next
+     * chain read.
+     */
+    onPropose: () => Promise<{
+        opId: bigint | string;
+        validAfter: number | bigint;
+    }>;
+    /**
+     * Submits the execute (add-device) or finalize (guardian-recovery)
+     * OE once the timelock has elapsed.
+     */
+    onExecute: (opId: bigint | string) => Promise<void>;
+    /**
+     * Optional cancel handler. When omitted the cancel button is hidden.
+     * Add-device uses `cancel_pending_op` (any owner); guardian-recovery
+     * uses `cancel_recovery` (the original owner, if they resurface).
+     */
+    onCancel?: (opId: bigint | string) => Promise<void>;
+    /**
+     * Optional className for the root element. Compose with the
+     * `data-chipi-recover-*` selectors for styling.
+     */
+    className?: string;
+    /**
+     * Clock override for tests / chain-time logic. Defaults to
+     * `Math.floor(Date.now() / 1000)`.
+     */
+    nowSecs?: number;
+}
+declare function Recover(props: RecoverProps): React.ReactElement;
+
+export { ChipiProvider, type PasskeyAdapter, Recover, type RecoverProps, useChipiContext };

package/dist/index.js

@@ -717,6 +717,25 @@ function useUpdateWalletEncryption() {
     reset: mutation.reset
   };
 }
+function useMigrateWalletToShhh() {
+  const { chipiSDK } = useChipiContext();
+  const mutation = reactQuery.useMutation({
+    mutationFn: async (input) => {
+      const { bearerToken, ...rest } = input;
+      return chipiSDK.wallets.migrateToShhh(rest, bearerToken);
+    }
+  });
+  return {
+    migrate: mutation.mutate,
+    migrateAsync: mutation.mutateAsync,
+    data: mutation.data,
+    isLoading: mutation.isPending,
+    isError: mutation.isError,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+    reset: mutation.reset
+  };
+}
 function useTransfer(config) {
   const { chipiSDK, passkeyAdapter } = useChipiContext();
   const mutation = reactQuery.useMutation({
@@ -1602,6 +1621,313 @@ function useX402Payment(config) {
     paymentCount
   };
 }
+function useShhhSigner() {
+  return React.useMemo(
+    () => ({
+      signWithStark: (params) => backend.buildStarkEnvelope({
+        privateKey: params.privateKey,
+        messageHash: params.messageHash
+      }),
+      signWithPhantom: (params) => backend.buildEd25519Envelope({
+        privateKey: params.privateKey,
+        messageHash: params.messageHash
+      }),
+      signWithMetaMask: (params) => backend.buildEip191EnvelopeFromSignature({
+        signatureHex: params.signatureHex,
+        pubkey: params.pubkey
+      }),
+      signWithPasskey: (params) => backend.buildWebAuthnEnvelopeFromAssertion({
+        authenticatorData: params.authenticatorData,
+        clientDataJSON: params.clientDataJSON,
+        signatureDer: params.signatureDer,
+        pubkey: params.pubkey,
+        messageHash: params.messageHash,
+        yParity: params.yParity ?? 0n
+      }),
+      signWithAppleIdToken: (params) => backend.buildJwtAppleSubEnvelopeFromTokenResponse({
+        idToken: params.idToken,
+        pubkey: params.pubkey,
+        messageHash: params.messageHash
+      })
+    }),
+    []
+  );
+}
+function useGuardianRecovery() {
+  return React.useMemo(
+    () => ({
+      buildProposeAddOwner: (args) => backend.buildProposeAddOwnerCall(args),
+      buildExecuteAddOwner: (args) => backend.buildExecuteAddOwnerCall(args),
+      buildProposeRemoveOwner: (args) => backend.buildProposeRemoveOwnerCall(args),
+      buildExecuteRemoveOwner: (args) => backend.buildExecuteRemoveOwnerCall(args),
+      buildProposeRotateOwner: (args) => backend.buildProposeRotateOwnerCall(args),
+      buildExecuteRotateOwner: (args) => backend.buildExecuteRotateOwnerCall(args),
+      buildProposeSetThreshold: (args) => backend.buildProposeSetThresholdCall(args),
+      buildExecuteSetThreshold: (args) => backend.buildExecuteSetThresholdCall(args),
+      buildCancelPendingOp: (args) => backend.buildCancelPendingOpCall(args),
+      buildInitiateRecovery: (args) => backend.buildInitiateRecoveryCall(args),
+      buildCancelRecovery: (args) => backend.buildCancelRecoveryCall(args),
+      buildFinalizeRecovery: (args) => backend.buildFinalizeRecoveryCall(args),
+      isReady: (validAfterSecs, nowSecs) => backend.isReadyToExecute(validAfterSecs, nowSecs ?? Math.floor(Date.now() / 1e3)),
+      secondsRemaining: (validAfterSecs, nowSecs) => backend.secondsUntilExecutable(validAfterSecs, nowSecs ?? Math.floor(Date.now() / 1e3)),
+      TIMELOCK_SECONDS: backend.TIMELOCK_SECONDS,
+      DEFAULT_OP_EXPIRY_SECONDS: backend.DEFAULT_OP_EXPIRY_SECONDS,
+      ROLE_OWNER: backend.ROLE_OWNER,
+      ROLE_GUARDIAN: backend.ROLE_GUARDIAN,
+      OP_ADD_OWNER: backend.OP_ADD_OWNER,
+      OP_REMOVE_OWNER: backend.OP_REMOVE_OWNER,
+      OP_ROTATE_OWNER: backend.OP_ROTATE_OWNER,
+      OP_SET_THRESHOLD: backend.OP_SET_THRESHOLD
+    }),
+    []
+  );
+}
+function useThresholdSign(opts) {
+  const { threshold } = opts;
+  const [collected, setCollected] = React.useState([]);
+  const [signedOwnerIds, setSignedOwnerIds] = React.useState([]);
+  const [error, setError] = React.useState(null);
+  const signedOwnerIdsRef = React.useRef([]);
+  const addEnvelope = React.useCallback((envelope) => {
+    let ownerId;
+    try {
+      ownerId = backend.assertValidV2Snip12Envelope(envelope);
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      setError(err);
+      return false;
+    }
+    if (signedOwnerIdsRef.current.some((id) => id === ownerId)) {
+      const err = new Error(
+        `THRESH: owner_id 0x${ownerId.toString(16)} has already signed; use removeEnvelope first if you want to replace their envelope.`
+      );
+      setError(err);
+      return false;
+    }
+    signedOwnerIdsRef.current = [...signedOwnerIdsRef.current, ownerId];
+    setCollected((prev) => [...prev, envelope]);
+    setSignedOwnerIds(signedOwnerIdsRef.current);
+    setError(null);
+    return true;
+  }, []);
+  const removeEnvelope = React.useCallback((ownerId) => {
+    const matchIndex = signedOwnerIdsRef.current.findIndex((id) => id === ownerId);
+    if (matchIndex < 0) return;
+    signedOwnerIdsRef.current = signedOwnerIdsRef.current.filter((id) => id !== ownerId);
+    setCollected((prev) => prev.filter((_, i) => i !== matchIndex));
+    setSignedOwnerIds(signedOwnerIdsRef.current);
+    setError(null);
+  }, []);
+  const reset = React.useCallback(() => {
+    signedOwnerIdsRef.current = [];
+    setCollected([]);
+    setSignedOwnerIds([]);
+    setError(null);
+  }, []);
+  const finalize = React.useCallback(() => {
+    if (collected.length < threshold) {
+      throw new Error(
+        `THRESH: cannot finalize \u2014 need ${threshold} envelopes, have ${collected.length}. Wait for more owners to sign.`
+      );
+    }
+    return backend.buildThresholdEnvelope({ innerEnvelopes: collected });
+  }, [collected, threshold]);
+  const state = React.useMemo(
+    () => ({
+      threshold,
+      collected,
+      signedOwnerIds,
+      isReady: collected.length >= threshold,
+      error
+    }),
+    [threshold, collected, signedOwnerIds, error]
+  );
+  const stateless = React.useMemo(
+    () => ({
+      assemble: (args) => backend.buildThresholdEnvelope(args),
+      parse: (args) => backend.parseThresholdEnvelope(args.envelope),
+      estimateGasOverhead: (args) => backend.estimateThresholdGasOverhead(args.owners),
+      MIN_THRESHOLD_OWNERS: backend.MIN_THRESHOLD_OWNERS
+    }),
+    []
+  );
+  return {
+    ...stateless,
+    state,
+    addEnvelope,
+    removeEnvelope,
+    reset,
+    finalize
+  };
+}
+function deriveStaticPhase(pendingOp, executed, isReady, nowSecs) {
+  if (executed) return "done";
+  if (!pendingOp) return "form-idle";
+  return isReady(pendingOp.validAfter, nowSecs) ? "ready-to-execute" : "awaiting-timelock";
+}
+function shortPubkey(bytes) {
+  if (bytes.length === 0) return "(empty)";
+  const first = bytes[0].toString(16);
+  return first.length > 12 ? `0x${first.slice(0, 8)}\u2026${first.slice(-4)}` : `0x${first}`;
+}
+function Recover(props) {
+  const { mode, walletAddress, newOwner, pendingOp, onCancel, className, nowSecs } = props;
+  const recovery = useGuardianRecovery();
+  const [executed, setExecuted] = React.useState(false);
+  const [submittingAction, setSubmittingAction] = React.useState(
+    null
+  );
+  const [error, setError] = React.useState(null);
+  const [optimisticPendingOp, setOptimisticPendingOp] = React.useState(null);
+  React.useEffect(() => {
+    if (pendingOp) setOptimisticPendingOp(null);
+  }, [pendingOp]);
+  const activePendingOp = pendingOp ?? optimisticPendingOp ?? null;
+  const [tick, setTick] = React.useState(0);
+  React.useEffect(() => {
+    if (!activePendingOp || executed) return;
+    const ready = recovery.isReady(activePendingOp.validAfter, nowSecs);
+    if (ready) return;
+    const id = setInterval(() => setTick((t) => t + 1), 1e3);
+    return () => clearInterval(id);
+  }, [activePendingOp, executed, recovery, nowSecs, tick]);
+  const phase = React.useMemo(() => {
+    if (submittingAction === "propose") return "submitting-propose";
+    if (submittingAction === "execute") return "submitting-execute";
+    if (submittingAction === "cancel") return "submitting-cancel";
+    return deriveStaticPhase(activePendingOp, executed, recovery.isReady, nowSecs);
+  }, [submittingAction, activePendingOp, executed, recovery, nowSecs, tick]);
+  const secondsRemaining = React.useMemo(() => {
+    if (!activePendingOp) return 0;
+    return recovery.secondsRemaining(activePendingOp.validAfter, nowSecs);
+  }, [activePendingOp, recovery, nowSecs, tick]);
+  const handlePropose = React.useCallback(async () => {
+    setError(null);
+    setSubmittingAction("propose");
+    try {
+      const result = await props.onPropose();
+      setOptimisticPendingOp({
+        opId: result.opId,
+        validAfter: result.validAfter
+      });
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error(String(e)));
+    } finally {
+      setSubmittingAction(null);
+    }
+  }, [props]);
+  const handleExecute = React.useCallback(async () => {
+    if (!activePendingOp) return;
+    setError(null);
+    setSubmittingAction("execute");
+    try {
+      await props.onExecute(activePendingOp.opId);
+      setExecuted(true);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error(String(e)));
+    } finally {
+      setSubmittingAction(null);
+    }
+  }, [activePendingOp, props]);
+  const handleCancel = React.useCallback(async () => {
+    if (!activePendingOp || !onCancel) return;
+    setError(null);
+    setSubmittingAction("cancel");
+    try {
+      await onCancel(activePendingOp.opId);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error(String(e)));
+    } finally {
+      setSubmittingAction(null);
+    }
+  }, [activePendingOp, onCancel]);
+  const isAddDevice = mode === "add-device";
+  const proposeLabel = isAddDevice ? "Propose new device" : "Initiate recovery";
+  const executeLabel = isAddDevice ? "Execute add-owner" : "Finalize recovery";
+  const timelockDescription = isAddDevice ? "48-hour timelock before this device becomes active." : "7-day timelock before the recovered wallet becomes active.";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-chipi-recover-root": "",
+      "data-chipi-recover-mode": mode,
+      "data-chipi-recover-phase": phase,
+      className,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("header", { "data-chipi-recover-header": "", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-wallet-address": "", children: String(walletAddress) }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-new-owner-kind": "", children: newOwner.kind }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-new-owner-label": "", children: newOwner.label }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-new-owner-pubkey": "", children: shortPubkey(newOwner.pubkeyBytes) })
+        ] }),
+        phase === "form-idle" && /* @__PURE__ */ jsxRuntime.jsxs("section", { "data-chipi-recover-section": "propose", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-description": "", children: timelockDescription }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              "data-chipi-recover-action": "propose",
+              onClick: handlePropose,
+              disabled: submittingAction !== null,
+              children: proposeLabel
+            }
+          )
+        ] }),
+        phase === "submitting-propose" && /* @__PURE__ */ jsxRuntime.jsx("section", { "data-chipi-recover-section": "propose", children: /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-status": "submitting", children: "Submitting\u2026" }) }),
+        phase === "awaiting-timelock" && activePendingOp && /* @__PURE__ */ jsxRuntime.jsxs("section", { "data-chipi-recover-section": "awaiting", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-status": "awaiting", children: timelockDescription }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "p",
+            {
+              "data-chipi-recover-countdown": "",
+              "data-chipi-recover-seconds-remaining": String(secondsRemaining),
+              children: [
+                secondsRemaining,
+                "s remaining"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-op-id": "", children: String(activePendingOp.opId) }),
+          onCancel && /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              "data-chipi-recover-action": "cancel",
+              onClick: handleCancel,
+              disabled: submittingAction !== null,
+              children: "Cancel pending op"
+            }
+          )
+        ] }),
+        (phase === "ready-to-execute" || phase === "submitting-execute") && activePendingOp && /* @__PURE__ */ jsxRuntime.jsxs("section", { "data-chipi-recover-section": "execute", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-status": "ready", children: "Timelock elapsed." }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              "data-chipi-recover-action": "execute",
+              onClick: handleExecute,
+              disabled: submittingAction !== null,
+              children: executeLabel
+            }
+          ),
+          onCancel && /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              "data-chipi-recover-action": "cancel",
+              onClick: handleCancel,
+              disabled: submittingAction !== null,
+              children: "Cancel pending op"
+            }
+          )
+        ] }),
+        phase === "submitting-cancel" && /* @__PURE__ */ jsxRuntime.jsx("section", { "data-chipi-recover-section": "cancel", children: /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-status": "submitting", children: "Cancelling\u2026" }) }),
+        phase === "done" && /* @__PURE__ */ jsxRuntime.jsx("section", { "data-chipi-recover-section": "done", children: /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-status": "done", children: isAddDevice ? "New device added." : "Wallet recovered." }) }),
+        error && /* @__PURE__ */ jsxRuntime.jsx("p", { "data-chipi-recover-error": "", role: "alert", children: error.message })
+      ]
+    }
+  );
+}
 
 Object.defineProperty(exports, "Chain", {
   enumerable: true,
@@ -1612,6 +1938,7 @@ Object.defineProperty(exports, "ChainToken", {
   get: function () { return types.ChainToken; }
 });
 exports.ChipiProvider = ChipiProvider;
+exports.Recover = Recover;
 exports.useAddSessionKeyToContract = useAddSessionKeyToContract;
 exports.useApprove = useApprove;
 exports.useCallAnyContract = useCallAnyContract;
@@ -1630,11 +1957,15 @@ exports.useGetTransaction = useGetTransaction;
 exports.useGetTransactionList = useGetTransactionList;
 exports.useGetTransactionStatus = useGetTransactionStatus;
 exports.useGetWallet = useGetWallet;
+exports.useGuardianRecovery = useGuardianRecovery;
 exports.useMigrateWalletToPasskey = useMigrateWalletToPasskey;
+exports.useMigrateWalletToShhh = useMigrateWalletToShhh;
 exports.usePurchaseSku = usePurchaseSku;
 exports.useRecordSendTransaction = useRecordSendTransaction;
 exports.useRevokeSessionKey = useRevokeSessionKey;
+exports.useShhhSigner = useShhhSigner;
 exports.useSyncOnChainTransfers = useSyncOnChainTransfers;
+exports.useThresholdSign = useThresholdSign;
 exports.useTransfer = useTransfer;
 exports.useUpdateWalletEncryption = useUpdateWalletEncryption;
 exports.useX402Payment = useX402Payment;