@chipi-stack/chipi-react 14.13.0 → 14.14.0

package/dist/hooks.mjs

@@ -23,6 +23,18 @@ function useChipiContext() {
   }
   return context;
 }
+
+// src/utils/with-error-code.ts
+function withErrorCode(wrapped, original) {
+  const code = original.code;
+  if (typeof code === "string") {
+    Object.defineProperty(wrapped, "code", { value: code, enumerable: true });
+  }
+  Object.defineProperty(wrapped, "cause", { value: original, enumerable: false });
+  return wrapped;
+}
+
+// src/hooks/useCreateWallet.ts
 function useCreateWallet() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation({
@@ -53,7 +65,7 @@ function useCreateWallet() {
           }
         } catch (error) {
           if (error instanceof Error) {
-            throw new Error(`Passkey creation failed: ${error.message}`);
+            throw withErrorCode(new Error(`Passkey creation failed: ${error.message}`), error);
           }
           throw new Error("Failed to create passkey for wallet");
         }
@@ -133,6 +145,17 @@ function useGetWallet(input) {
     fetchWallet
   };
 }
+
+// src/utils/wallet-capabilities.ts
+var SHHH_SESSION_SIGNER_KINDS = /* @__PURE__ */ new Set(["STARK", "ED25519"]);
+function walletSupportsSessions(wallet) {
+  if (!wallet) return false;
+  if (wallet.walletType === "CHIPI") return true;
+  if (wallet.walletType === "SHHH") {
+    return !wallet.signerKind || SHHH_SESSION_SIGNER_KINDS.has(wallet.signerKind);
+  }
+  return false;
+}
 function useChipiWallet(config3) {
   const { chipiSDK } = useChipiContext();
   const queryClient = useQueryClient();
@@ -213,7 +236,7 @@ function useChipiWallet(config3) {
     const data = walletQuery.data;
     return {
       ...data,
-      supportsSessionKeys: data.walletType === "CHIPI",
+      supportsSessionKeys: walletSupportsSessions(data),
       shortAddress: formatAddress(data.publicKey)
     };
   }, [walletQuery.data, walletQuery.isLoading]);
@@ -270,6 +293,7 @@ function useChipiSession(config3) {
   const {
     wallet,
     encryptKey,
+    getEncryptKey,
     getBearerToken,
     storedSession,
     onSessionCreated,
@@ -283,10 +307,13 @@ function useChipiSession(config3) {
   useEffect(() => {
     setLocalSession(storedSession ?? null);
   }, [storedSession]);
-  const supportsSession = useMemo(() => {
-    if (!wallet) return false;
-    return wallet.walletType === "CHIPI";
-  }, [wallet]);
+  const supportsSession = useMemo(() => walletSupportsSessions(wallet), [wallet]);
+  const resolveEncryptKey = useCallback(async () => {
+    const key = encryptKey || (getEncryptKey ? await getEncryptKey() : void 0);
+    if (!key) throw new Error("Encryption key (PIN) is required");
+    return key;
+  }, [encryptKey, getEncryptKey]);
+  const [awaitingRegistrationUntil, setAwaitingRegistrationUntil] = useState(null);
   const sessionStatusQuery = useQuery({
     queryKey: ["chipi-session-status", wallet?.publicKey, localSession?.publicKey],
     queryFn: async () => {
@@ -299,34 +326,41 @@ function useChipiSession(config3) {
     enabled: Boolean(
       autoCheckStatus && wallet?.publicKey && localSession?.publicKey && supportsSession
     ),
-    staleTime: 3e4
+    staleTime: 3e4,
     // 30 seconds
+    // The registration hash comes back before the transaction is in a block, so
+    // right after registerSession the struct can still read as zero. Poll until
+    // it shows up (or for two minutes), then go back to on-demand reads.
+    refetchInterval: (query) => awaitingRegistrationUntil !== null && Date.now() < awaitingRegistrationUntil && (query.state.data?.validUntil ?? 0) === 0 ? 3e3 : false
   });
+  const [revokedSessionKey, setRevokedSessionKey] = useState(null);
   const sessionState = useMemo(() => {
     if (!localSession) return "none";
+    if (revokedSessionKey === localSession.publicKey) return "revoked";
+    if (localSession.validUntil * 1e3 < Date.now()) return "expired";
     const status = sessionStatusQuery.data;
     if (status) {
-      if (!status.isActive) return "revoked";
+      if (status.validUntil === 0) return "created";
       if (status.validUntil * 1e3 < Date.now()) return "expired";
       if (status.remainingCalls <= 0) return "expired";
+      if (!status.isActive) return "revoked";
       return "active";
     }
-    if (localSession.validUntil * 1e3 < Date.now()) return "expired";
     return "created";
-  }, [localSession, sessionStatusQuery.data]);
+  }, [localSession, revokedSessionKey, sessionStatusQuery.data]);
   const hasActiveSession = sessionState === "active";
   const isSessionExpired = sessionState === "expired";
   const remainingCalls = sessionStatusQuery.data?.remainingCalls;
   const createSessionMutation = useMutation(
     {
       mutationFn: async (params = {}) => {
-        if (!encryptKey) throw new Error("Encryption key (PIN) is required");
         if (!supportsSession)
           throw new Error(
-            "Wallet does not support sessions. Only CHIPI wallets support session keys."
+            "Wallet does not support sessions. Session keys need a CHIPI wallet or a SHHH wallet with a STARK / ED25519 signer."
           );
+        const key = await resolveEncryptKey();
         const sessionData = chipiSDK.sessions.createSessionKey({
-          encryptKey,
+          encryptKey: key,
           durationSeconds: params.durationSeconds ?? defaultDurationSeconds
         });
         return sessionData;
@@ -346,28 +380,38 @@ function useChipiSession(config3) {
   const registerSessionMutation = useMutation({
     mutationFn: async (sessionConfig = {}) => {
       if (!wallet) throw new Error("Wallet is required");
-      if (!localSession) throw new Error("No session to register. Call createSession first.");
-      if (!encryptKey) throw new Error("Encryption key (PIN) is required");
+      const sessionPublicKey = sessionConfig.sessionPublicKey ?? localSession?.publicKey;
+      const validUntil = sessionConfig.validUntil ?? localSession?.validUntil;
+      if (!sessionPublicKey || validUntil === void 0)
+        throw new Error(
+          "No session to register. Call createSession first, or pass sessionPublicKey and validUntil."
+        );
       if (!supportsSession) throw new Error("Wallet does not support sessions");
+      const key = await resolveEncryptKey();
       const bearerToken = await getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
-      const txHash = await chipiSDK.sessions.addSessionKeyToContract(
-        {
-          encryptKey,
-          wallet,
-          sessionConfig: {
-            sessionPublicKey: localSession.publicKey,
-            validUntil: sessionConfig.validUntil ?? localSession.validUntil,
-            maxCalls: sessionConfig.maxCalls ?? defaultMaxCalls,
-            allowedEntrypoints: sessionConfig.allowedEntrypoints ?? []
-          }
-        },
-        bearerToken
-      );
-      return txHash;
+      const params = {
+        encryptKey: key,
+        wallet,
+        sessionConfig: {
+          sessionPublicKey,
+          validUntil,
+          maxCalls: sessionConfig.maxCalls ?? defaultMaxCalls,
+          allowedEntrypoints: sessionConfig.allowedEntrypoints ?? []
+        }
+      };
+      if (sessionConfig.spendingPolicies?.length) {
+        return chipiSDK.sessions.setupSession(
+          { ...params, spendingPolicies: sessionConfig.spendingPolicies },
+          bearerToken
+        );
+      }
+      return chipiSDK.sessions.addSessionKeyToContract(params, bearerToken);
     },
     onSuccess: () => {
       setError(null);
+      if (localSession && revokedSessionKey === localSession.publicKey) setRevokedSessionKey(null);
+      setAwaitingRegistrationUntil(Date.now() + 12e4);
       queryClient.invalidateQueries({
         queryKey: ["chipi-session-status", wallet?.publicKey, localSession?.publicKey]
       });
@@ -377,25 +421,28 @@ function useChipiSession(config3) {
     }
   });
   const revokeSessionMutation = useMutation({
-    mutationFn: async () => {
+    mutationFn: async (sessionPublicKey) => {
       if (!wallet) throw new Error("Wallet is required");
-      if (!localSession) throw new Error("No session to revoke");
-      if (!encryptKey) throw new Error("Encryption key (PIN) is required");
+      const target = sessionPublicKey ?? localSession?.publicKey;
+      if (!target) throw new Error("No session to revoke");
       if (!supportsSession) throw new Error("Wallet does not support sessions");
+      const key = await resolveEncryptKey();
       const bearerToken = await getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
       const txHash = await chipiSDK.sessions.revokeSessionKey(
         {
-          encryptKey,
+          encryptKey: key,
           wallet,
-          sessionPublicKey: localSession.publicKey
+          sessionPublicKey: target
         },
         bearerToken
       );
       return txHash;
     },
-    onSuccess: () => {
+    onSuccess: (_txHash, sessionPublicKey) => {
       setError(null);
+      const target = sessionPublicKey ?? localSession?.publicKey;
+      if (target) setRevokedSessionKey(target);
       queryClient.invalidateQueries({
         queryKey: ["chipi-session-status", wallet?.publicKey, localSession?.publicKey]
       });
@@ -408,13 +455,13 @@ function useChipiSession(config3) {
     mutationFn: async (calls) => {
       if (!wallet) throw new Error("Wallet is required");
       if (!localSession) throw new Error("No active session");
-      if (!encryptKey) throw new Error("Encryption key (PIN) is required");
       if (!hasActiveSession) throw new Error("Session is not active. Register the session first.");
+      const key = await resolveEncryptKey();
       const bearerToken = await getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
       const txHash = await chipiSDK.executeTransactionWithSession({
         params: {
-          encryptKey,
+          encryptKey: key,
           wallet,
           session: localSession,
           calls
@@ -438,13 +485,13 @@ function useChipiSession(config3) {
       if (!wallet) throw new Error("Wallet is required");
       if (!localSession)
         throw new Error("No session to set policy on. Create and register a session first.");
-      if (!encryptKey) throw new Error("Encryption key (PIN) is required");
       if (!supportsSession) throw new Error("Wallet does not support sessions");
+      const key = await resolveEncryptKey();
       const bearerToken = await getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
       const txHash = await chipiSDK.sessions.setSpendingPolicy(
         {
-          encryptKey,
+          encryptKey: key,
           wallet,
           spendingPolicyConfig: {
             sessionPublicKey: localSession.publicKey,
@@ -466,13 +513,13 @@ function useChipiSession(config3) {
     mutationFn: async (token) => {
       if (!wallet) throw new Error("Wallet is required");
       if (!localSession) throw new Error("No session to remove policy from");
-      if (!encryptKey) throw new Error("Encryption key (PIN) is required");
       if (!supportsSession) throw new Error("Wallet does not support sessions");
+      const key = await resolveEncryptKey();
       const bearerToken = await getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
       const txHash = await chipiSDK.sessions.removeSpendingPolicy(
         {
-          encryptKey,
+          encryptKey: key,
           wallet,
           sessionPublicKey: localSession.publicKey,
           token
@@ -500,9 +547,14 @@ function useChipiSession(config3) {
     },
     [registerSessionMutation]
   );
-  const revokeSession = useCallback(async () => {
-    return revokeSessionMutation.mutateAsync();
-  }, [revokeSessionMutation]);
+  const revokeSession = useCallback(
+    async (sessionPublicKey) => {
+      return revokeSessionMutation.mutateAsync(
+        typeof sessionPublicKey === "string" ? sessionPublicKey : void 0
+      );
+    },
+    [revokeSessionMutation]
+  );
   const executeWithSession = useCallback(
     async (calls) => {
       return executeWithSessionMutation.mutateAsync(calls);
@@ -636,7 +688,7 @@ function useMigrateWalletToPasskey() {
         };
       } catch (error) {
         if (error instanceof Error) {
-          throw new Error(`Migration failed: ${error.message}`);
+          throw withErrorCode(new Error(`Migration failed: ${error.message}`), error);
         }
         throw new Error("Failed to migrate wallet to passkey");
       }