@chipi-stack/chipi-react 14.4.0 → 14.7.0

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import React, { createContext, useContext, useMemo, useCallback, useState, useEffect, useRef } from 'react';
 import { QueryClient, QueryClientProvider, useMutation, useQueryClient, useQuery } from '@tanstack/react-query';
-import { ChipiSDK, decryptPrivateKey, encryptPrivateKey } from '@chipi-stack/backend';
+import { ChipiSDK, decryptPrivateKey, encryptPrivateKey, buildJwtAppleSubEnvelopeFromTokenResponse, buildWebAuthnEnvelopeFromAssertion, buildEip191EnvelopeFromSignature, buildEd25519Envelope, buildStarkEnvelope, OP_SET_THRESHOLD, OP_ROTATE_OWNER, OP_REMOVE_OWNER, OP_ADD_OWNER, ROLE_GUARDIAN, ROLE_OWNER, DEFAULT_OP_EXPIRY_SECONDS, TIMELOCK_SECONDS, secondsUntilExecutable, isReadyToExecute, buildFinalizeRecoveryCall, buildCancelRecoveryCall, buildInitiateRecoveryCall, buildCancelPendingOpCall, buildExecuteSetThresholdCall, buildProposeSetThresholdCall, buildExecuteRotateOwnerCall, buildProposeRotateOwnerCall, buildExecuteRemoveOwnerCall, buildProposeRemoveOwnerCall, buildExecuteAddOwnerCall, buildProposeAddOwnerCall, assertValidV2Snip12Envelope, buildThresholdEnvelope, MIN_THRESHOLD_OWNERS, estimateThresholdGasOverhead, parseThresholdEnvelope } from '@chipi-stack/backend';
 import { createWalletPasskey, getWalletEncryptKey } from '@chipi-stack/chipi-passkey';
-import { jsx } from 'react/jsx-runtime';
+import { jsx, jsxs } from 'react/jsx-runtime';
 import { ChipiApiError } from '@chipi-stack/shared';
 import { OnChainTxStatus, Chain, ChainToken } from '@chipi-stack/types';
 export { Chain, ChainToken } from '@chipi-stack/types';
@@ -712,6 +712,25 @@ function useUpdateWalletEncryption() {
     reset: mutation.reset
   };
 }
+function useMigrateWalletToShhh() {
+  const { chipiSDK } = useChipiContext();
+  const mutation = 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 = useMutation({
@@ -1597,7 +1616,314 @@ function useX402Payment(config) {
     paymentCount
   };
 }
+function useShhhSigner() {
+  return useMemo(
+    () => ({
+      signWithStark: (params) => buildStarkEnvelope({
+        privateKey: params.privateKey,
+        messageHash: params.messageHash
+      }),
+      signWithPhantom: (params) => buildEd25519Envelope({
+        privateKey: params.privateKey,
+        messageHash: params.messageHash
+      }),
+      signWithMetaMask: (params) => buildEip191EnvelopeFromSignature({
+        signatureHex: params.signatureHex,
+        pubkey: params.pubkey
+      }),
+      signWithPasskey: (params) => buildWebAuthnEnvelopeFromAssertion({
+        authenticatorData: params.authenticatorData,
+        clientDataJSON: params.clientDataJSON,
+        signatureDer: params.signatureDer,
+        pubkey: params.pubkey,
+        messageHash: params.messageHash,
+        yParity: params.yParity ?? 0n
+      }),
+      signWithAppleIdToken: (params) => buildJwtAppleSubEnvelopeFromTokenResponse({
+        idToken: params.idToken,
+        pubkey: params.pubkey,
+        messageHash: params.messageHash
+      })
+    }),
+    []
+  );
+}
+function useGuardianRecovery() {
+  return useMemo(
+    () => ({
+      buildProposeAddOwner: (args) => buildProposeAddOwnerCall(args),
+      buildExecuteAddOwner: (args) => buildExecuteAddOwnerCall(args),
+      buildProposeRemoveOwner: (args) => buildProposeRemoveOwnerCall(args),
+      buildExecuteRemoveOwner: (args) => buildExecuteRemoveOwnerCall(args),
+      buildProposeRotateOwner: (args) => buildProposeRotateOwnerCall(args),
+      buildExecuteRotateOwner: (args) => buildExecuteRotateOwnerCall(args),
+      buildProposeSetThreshold: (args) => buildProposeSetThresholdCall(args),
+      buildExecuteSetThreshold: (args) => buildExecuteSetThresholdCall(args),
+      buildCancelPendingOp: (args) => buildCancelPendingOpCall(args),
+      buildInitiateRecovery: (args) => buildInitiateRecoveryCall(args),
+      buildCancelRecovery: (args) => buildCancelRecoveryCall(args),
+      buildFinalizeRecovery: (args) => buildFinalizeRecoveryCall(args),
+      isReady: (validAfterSecs, nowSecs) => isReadyToExecute(validAfterSecs, nowSecs ?? Math.floor(Date.now() / 1e3)),
+      secondsRemaining: (validAfterSecs, nowSecs) => secondsUntilExecutable(validAfterSecs, nowSecs ?? Math.floor(Date.now() / 1e3)),
+      TIMELOCK_SECONDS,
+      DEFAULT_OP_EXPIRY_SECONDS,
+      ROLE_OWNER,
+      ROLE_GUARDIAN,
+      OP_ADD_OWNER,
+      OP_REMOVE_OWNER,
+      OP_ROTATE_OWNER,
+      OP_SET_THRESHOLD
+    }),
+    []
+  );
+}
+function useThresholdSign(opts) {
+  const { threshold } = opts;
+  const [collected, setCollected] = useState([]);
+  const [signedOwnerIds, setSignedOwnerIds] = useState([]);
+  const [error, setError] = useState(null);
+  const signedOwnerIdsRef = useRef([]);
+  const addEnvelope = useCallback((envelope) => {
+    let ownerId;
+    try {
+      ownerId = 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 = 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 = useCallback(() => {
+    signedOwnerIdsRef.current = [];
+    setCollected([]);
+    setSignedOwnerIds([]);
+    setError(null);
+  }, []);
+  const finalize = 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 buildThresholdEnvelope({ innerEnvelopes: collected });
+  }, [collected, threshold]);
+  const state = useMemo(
+    () => ({
+      threshold,
+      collected,
+      signedOwnerIds,
+      isReady: collected.length >= threshold,
+      error
+    }),
+    [threshold, collected, signedOwnerIds, error]
+  );
+  const stateless = useMemo(
+    () => ({
+      assemble: (args) => buildThresholdEnvelope(args),
+      parse: (args) => parseThresholdEnvelope(args.envelope),
+      estimateGasOverhead: (args) => estimateThresholdGasOverhead(args.owners),
+      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] = useState(false);
+  const [submittingAction, setSubmittingAction] = useState(
+    null
+  );
+  const [error, setError] = useState(null);
+  const [optimisticPendingOp, setOptimisticPendingOp] = useState(null);
+  useEffect(() => {
+    if (pendingOp) setOptimisticPendingOp(null);
+  }, [pendingOp]);
+  const activePendingOp = pendingOp ?? optimisticPendingOp ?? null;
+  const [tick, setTick] = useState(0);
+  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 = 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 = useMemo(() => {
+    if (!activePendingOp) return 0;
+    return recovery.secondsRemaining(activePendingOp.validAfter, nowSecs);
+  }, [activePendingOp, recovery, nowSecs, tick]);
+  const handlePropose = 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 = 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 = 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__ */ jsxs(
+    "div",
+    {
+      "data-chipi-recover-root": "",
+      "data-chipi-recover-mode": mode,
+      "data-chipi-recover-phase": phase,
+      className,
+      children: [
+        /* @__PURE__ */ jsxs("header", { "data-chipi-recover-header": "", children: [
+          /* @__PURE__ */ jsx("p", { "data-chipi-recover-wallet-address": "", children: String(walletAddress) }),
+          /* @__PURE__ */ jsx("p", { "data-chipi-recover-new-owner-kind": "", children: newOwner.kind }),
+          /* @__PURE__ */ jsx("p", { "data-chipi-recover-new-owner-label": "", children: newOwner.label }),
+          /* @__PURE__ */ jsx("p", { "data-chipi-recover-new-owner-pubkey": "", children: shortPubkey(newOwner.pubkeyBytes) })
+        ] }),
+        phase === "form-idle" && /* @__PURE__ */ jsxs("section", { "data-chipi-recover-section": "propose", children: [
+          /* @__PURE__ */ jsx("p", { "data-chipi-recover-description": "", children: timelockDescription }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              "data-chipi-recover-action": "propose",
+              onClick: handlePropose,
+              disabled: submittingAction !== null,
+              children: proposeLabel
+            }
+          )
+        ] }),
+        phase === "submitting-propose" && /* @__PURE__ */ jsx("section", { "data-chipi-recover-section": "propose", children: /* @__PURE__ */ jsx("p", { "data-chipi-recover-status": "submitting", children: "Submitting\u2026" }) }),
+        phase === "awaiting-timelock" && activePendingOp && /* @__PURE__ */ jsxs("section", { "data-chipi-recover-section": "awaiting", children: [
+          /* @__PURE__ */ jsx("p", { "data-chipi-recover-status": "awaiting", children: timelockDescription }),
+          /* @__PURE__ */ jsxs(
+            "p",
+            {
+              "data-chipi-recover-countdown": "",
+              "data-chipi-recover-seconds-remaining": String(secondsRemaining),
+              children: [
+                secondsRemaining,
+                "s remaining"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx("p", { "data-chipi-recover-op-id": "", children: String(activePendingOp.opId) }),
+          onCancel && /* @__PURE__ */ 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__ */ jsxs("section", { "data-chipi-recover-section": "execute", children: [
+          /* @__PURE__ */ jsx("p", { "data-chipi-recover-status": "ready", children: "Timelock elapsed." }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              "data-chipi-recover-action": "execute",
+              onClick: handleExecute,
+              disabled: submittingAction !== null,
+              children: executeLabel
+            }
+          ),
+          onCancel && /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              "data-chipi-recover-action": "cancel",
+              onClick: handleCancel,
+              disabled: submittingAction !== null,
+              children: "Cancel pending op"
+            }
+          )
+        ] }),
+        phase === "submitting-cancel" && /* @__PURE__ */ jsx("section", { "data-chipi-recover-section": "cancel", children: /* @__PURE__ */ jsx("p", { "data-chipi-recover-status": "submitting", children: "Cancelling\u2026" }) }),
+        phase === "done" && /* @__PURE__ */ jsx("section", { "data-chipi-recover-section": "done", children: /* @__PURE__ */ jsx("p", { "data-chipi-recover-status": "done", children: isAddDevice ? "New device added." : "Wallet recovered." }) }),
+        error && /* @__PURE__ */ jsx("p", { "data-chipi-recover-error": "", role: "alert", children: error.message })
+      ]
+    }
+  );
+}
 
-export { ChipiProvider, useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiContext, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuPurchase, useGetTokenBalance, useGetTransaction, useGetTransactionList, useGetTransactionStatus, useGetWallet, useMigrateWalletToPasskey, usePurchaseSku, useRecordSendTransaction, useRevokeSessionKey, useSyncOnChainTransfers, useTransfer, useUpdateWalletEncryption, useX402Payment };
+export { ChipiProvider, Recover, useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiContext, 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 };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map