@chipi-stack/chipi-react 13.13.0 → 14.0.0

package/dist/index.mjs

@@ -32,11 +32,7 @@ var createDefaultQueryClient = () => new QueryClient({
     }
   }
 });
-function ChipiProvider({
-  children,
-  config,
-  passkeyAdapter
-}) {
+function ChipiProvider({ children, config, passkeyAdapter }) {
   const queryClient = React.useMemo(() => createDefaultQueryClient(), []);
   const chipiSDK = React.useMemo(() => new ChipiSDK(config), [config]);
   const resolvedPasskeyAdapter = passkeyAdapter ?? defaultPasskeyAdapter;
@@ -80,6 +76,9 @@ function useCreateWallet() {
           throw new Error("Failed to create passkey for wallet");
         }
       }
+      if (!encryptKey) {
+        throw new Error("encryptKey is required when usePasskey is false");
+      }
       return chipiSDK.createWallet({
         params: {
           ...input.params,
@@ -106,8 +105,7 @@ function useGetWallet(input) {
   const query = useQuery({
     queryKey: ["wallet", input?.params?.externalUserId],
     queryFn: async () => {
-      if (!input || !input.params || !input.getBearerToken)
-        throw new Error("Input is required");
+      if (!input || !input.params || !input.getBearerToken) throw new Error("Input is required");
       const bearerToken = await input.getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
       return chipiSDK.getWallet(input.params, bearerToken);
@@ -149,22 +147,16 @@ function useGetWallet(input) {
 function useChipiWallet(config) {
   const { chipiSDK } = useChipiContext();
   const queryClient = useQueryClient();
-  const {
-    externalUserId,
-    getBearerToken,
-    defaultToken = "USDC",
-    enabled = true
-  } = config;
-  const isEnabled = Boolean(
-    enabled && externalUserId && externalUserId.trim() !== ""
-  );
+  const { externalUserId, getBearerToken, defaultToken = "USDC", enabled = true } = config;
+  const trimmedUserId = externalUserId?.trim() || null;
+  const isEnabled = Boolean(enabled && trimmedUserId);
   const walletQuery = useQuery({
-    queryKey: ["chipi-wallet", externalUserId],
+    queryKey: ["chipi-wallet", trimmedUserId],
     queryFn: async () => {
-      if (!externalUserId) return null;
+      if (!trimmedUserId) return null;
       const bearerToken = await getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
-      return chipiSDK.getWallet({ externalUserId }, bearerToken);
+      return chipiSDK.getWallet({ externalUserId: trimmedUserId }, bearerToken);
     },
     enabled: isEnabled,
     retry: (failureCount, error) => {
@@ -190,7 +182,7 @@ function useChipiWallet(config) {
         bearerToken
       );
     },
-    enabled: Boolean(walletPublicKey),
+    enabled: Boolean(isEnabled && walletPublicKey),
     retry: (failureCount, error) => {
       if (error instanceof ChipiApiError || error?.status) {
         return false;
@@ -200,14 +192,14 @@ function useChipiWallet(config) {
   });
   const createWalletMutation = useMutation({
     mutationFn: async ({ encryptKey, walletType = "CHIPI" }) => {
-      if (!externalUserId) throw new Error("External user ID is required");
+      if (!trimmedUserId) throw new Error("External user ID is required");
       const bearerToken = await getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
       return chipiSDK.createWallet({
         params: {
           chain: Chain.STARKNET,
           encryptKey,
-          externalUserId,
+          externalUserId: trimmedUserId,
           walletType
         },
         bearerToken
@@ -215,7 +207,7 @@ function useChipiWallet(config) {
     },
     onSuccess: () => {
       queryClient.invalidateQueries({
-        queryKey: ["chipi-wallet", externalUserId]
+        queryKey: ["chipi-wallet", trimmedUserId]
       });
     }
   });
@@ -290,14 +282,10 @@ function useChipiSession(config) {
     defaultMaxCalls = 1e3,
     autoCheckStatus = true
   } = config;
-  const [localSession, setLocalSession] = useState(
-    storedSession ?? null
-  );
+  const [localSession, setLocalSession] = useState(storedSession ?? null);
   const [error, setError] = useState(null);
   useEffect(() => {
-    if (storedSession) {
-      setLocalSession(storedSession);
-    }
+    setLocalSession(storedSession ?? null);
   }, [storedSession]);
   const supportsSession = useMemo(() => {
     if (!wallet) return false;
@@ -333,27 +321,32 @@ function useChipiSession(config) {
   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.");
-      const sessionData = chipiSDK.sessions.createSessionKey({
-        encryptKey,
-        durationSeconds: params.durationSeconds ?? defaultDurationSeconds
-      });
-      return sessionData;
-    },
-    onSuccess: async (sessionData) => {
-      setLocalSession(sessionData);
-      setError(null);
-      if (onSessionCreated) {
-        await onSessionCreated(sessionData);
+  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."
+          );
+        const sessionData = chipiSDK.sessions.createSessionKey({
+          encryptKey,
+          durationSeconds: params.durationSeconds ?? defaultDurationSeconds
+        });
+        return sessionData;
+      },
+      onSuccess: async (sessionData) => {
+        setLocalSession(sessionData);
+        setError(null);
+        if (onSessionCreated) {
+          await onSessionCreated(sessionData);
+        }
+      },
+      onError: (err) => {
+        setError(err);
       }
-    },
-    onError: (err) => {
-      setError(err);
     }
-  });
+  );
   const registerSessionMutation = useMutation({
     mutationFn: async (sessionConfig = {}) => {
       if (!wallet) throw new Error("Wallet is required");
@@ -514,22 +507,19 @@ function useMigrateWalletToPasskey() {
     mutationFn: async (input) => {
       const { wallet, oldEncryptKey, externalUserId, bearerToken } = input;
       try {
-        const passkeyResult = await createWalletPasskey(
-          externalUserId,
-          externalUserId
-          // Using externalUserId as userName
-        );
         let decryptedPrivateKey;
         try {
-          decryptedPrivateKey = decryptPrivateKey(
-            wallet.encryptedPrivateKey,
-            oldEncryptKey
-          );
-        } catch (error) {
+          decryptedPrivateKey = decryptPrivateKey(wallet.encryptedPrivateKey, oldEncryptKey);
+        } catch {
           throw new Error(
             "Failed to decrypt wallet with provided encryptKey. Please verify your PIN/password is correct."
           );
         }
+        const passkeyResult = await createWalletPasskey(
+          externalUserId,
+          externalUserId
+          // Using externalUserId as userName
+        );
         const newEncryptedPrivateKey = encryptPrivateKey(
           decryptedPrivateKey,
           passkeyResult.encryptKey
@@ -589,44 +579,49 @@ function useUpdateWalletEncryption() {
 }
 function useTransfer() {
   const { chipiSDK, passkeyAdapter } = useChipiContext();
-  const mutation = useMutation(
-    {
-      mutationFn: async (input) => {
-        let encryptKey = input.params.encryptKey;
-        if (input.params.usePasskey) {
-          if (!input.params.externalUserId) {
-            throw new Error(
-              "externalUserId is required when usePasskey is true"
-            );
+  const mutation = useMutation({
+    mutationFn: async (input) => {
+      let encryptKey = input.params.encryptKey;
+      if (input.params.usePasskey) {
+        if (!input.params.externalUserId) {
+          throw new Error("externalUserId is required when usePasskey is true");
+        }
+        try {
+          const key = await passkeyAdapter.getWalletEncryptKey({
+            externalUserId: input.params.externalUserId
+          });
+          if (!key) {
+            throw new Error("Passkey authentication was cancelled");
           }
-          try {
-            const key = await passkeyAdapter.getWalletEncryptKey({
-              externalUserId: input.params.externalUserId
-            });
-            if (!key) {
-              throw new Error("Passkey authentication was cancelled");
-            }
-            encryptKey = key;
-          } catch (error) {
-            if (error instanceof Error) {
-              throw new Error(
-                `Passkey authentication failed: ${error.message}`
-              );
-            }
-            throw new Error("Failed to authenticate with passkey");
+          encryptKey = key;
+        } catch (error) {
+          if (error instanceof DOMException && error.name === "NotAllowedError") {
+            throw new Error("Passkey authentication was cancelled by the user");
+          }
+          if (error instanceof Error) {
+            throw error;
           }
+          throw new Error("Failed to authenticate with passkey");
         }
-        return chipiSDK.transfer({
-          params: {
-            ...input.params,
-            amount: String(input.params.amount),
-            encryptKey
-          },
-          bearerToken: input.bearerToken
-        });
       }
+      if (!encryptKey) {
+        throw new Error("encryptKey is required when usePasskey is false");
+      }
+      const {
+        usePasskey: _usePasskey,
+        externalUserId: _externalUserId,
+        ...transferParams
+      } = input.params;
+      return chipiSDK.transfer({
+        params: {
+          ...transferParams,
+          amount: String(transferParams.amount),
+          encryptKey
+        },
+        bearerToken: input.bearerToken
+      });
     }
-  );
+  });
   return {
     transfer: mutation.mutate,
     transferAsync: mutation.mutateAsync,
@@ -662,10 +657,20 @@ function useApprove() {
           throw new Error("Failed to authenticate with passkey");
         }
       }
+      if (!encryptKey) {
+        throw new Error(
+          "encryptKey is required when usePasskey is false. Provide a PIN or enable usePasskey."
+        );
+      }
+      const {
+        usePasskey: _usePasskey,
+        externalUserId: _externalUserId,
+        ...approveParams
+      } = params.params;
       return chipiSDK.approve({
         params: {
-          ...params.params,
-          amount: String(params.params.amount),
+          ...approveParams,
+          amount: String(approveParams.amount),
           encryptKey
         },
         bearerToken: params.bearerToken
@@ -715,9 +720,8 @@ function useGetTransactionList(input) {
   });
   const fetchTransactionList = async (newInput) => {
     return queryClient.fetchQuery({
-      queryKey: buildQueryKey(newInput?.query),
+      queryKey: buildQueryKey(newInput.query),
       queryFn: async () => {
-        if (!newInput?.getBearerToken) throw new Error("getBearerToken is required");
         const bearerToken = await newInput.getBearerToken();
         if (!bearerToken) throw new Error("Bearer token is required");
         return chipiSDK.getTransactionList(newInput.query, bearerToken);
@@ -774,8 +778,7 @@ function useGetSkuPurchase(input) {
       queryKey: ["sku-purchase", newInput?.id],
       queryFn: async () => {
         if (!newInput?.id) throw new Error("id is required");
-        if (!newInput?.getBearerToken)
-          throw new Error("getBearerToken is required");
+        if (!newInput?.getBearerToken) throw new Error("getBearerToken is required");
         const bearerToken = await newInput.getBearerToken();
         if (!bearerToken) throw new Error("Bearer token is required");
         return chipiSDK.getSkuPurchase(newInput.id, bearerToken);
@@ -849,9 +852,7 @@ function useGetSku(input) {
       if (!bearerToken) throw new Error("Bearer token is required");
       return chipiSDK.getSku(input.id, bearerToken);
     },
-    enabled: Boolean(
-      input?.id && input?.getBearerToken && input.id.trim() !== ""
-    ),
+    enabled: Boolean(input?.id && input?.getBearerToken && input.id.trim() !== ""),
     retry: (failureCount, error) => {
       if (error instanceof ChipiApiError || error?.status) {
         return false;
@@ -864,14 +865,13 @@ function useGetSku(input) {
     return queryClient.fetchQuery({
       queryKey: ["sku", input2?.id],
       queryFn: async () => {
-        if (!input2?.getBearerToken)
-          throw new Error("getBearerToken is required");
+        if (!input2?.getBearerToken) throw new Error("getBearerToken is required");
         const bearerToken = await input2.getBearerToken();
         if (!bearerToken) throw new Error("Bearer token is required");
         return chipiSDK.getSku(input2.id, bearerToken);
       },
       retry: (failureCount, error) => {
-        if (error instanceof ChipiApiError || error?.code) {
+        if (error instanceof ChipiApiError || error?.status) {
           return false;
         }
         return failureCount < 3;
@@ -890,9 +890,7 @@ function useCallAnyContract() {
       let encryptKey = params.params.encryptKey;
       if (params.params.usePasskey) {
         if (!params.params.externalUserId) {
-          throw new Error(
-            "externalUserId is required when usePasskey is true"
-          );
+          throw new Error("externalUserId is required when usePasskey is true");
         }
         try {
           const key = await passkeyAdapter.getWalletEncryptKey({
@@ -903,17 +901,26 @@ function useCallAnyContract() {
           }
           encryptKey = key;
         } catch (error) {
+          if (error instanceof DOMException && error.name === "NotAllowedError") {
+            throw new Error("Passkey authentication was cancelled by the user");
+          }
           if (error instanceof Error) {
-            throw new Error(
-              `Passkey authentication failed: ${error.message}`
-            );
+            throw error;
           }
           throw new Error("Failed to authenticate with passkey");
         }
       }
+      if (!encryptKey) {
+        throw new Error("encryptKey is required when usePasskey is false");
+      }
+      const {
+        usePasskey: _usePasskey,
+        externalUserId: _externalUserId,
+        ...contractParams
+      } = params.params;
       return chipiSDK.callAnyContract({
         params: {
-          ...params.params,
+          ...contractParams,
           encryptKey
         },
         bearerToken: params.bearerToken
@@ -981,7 +988,8 @@ function useGetTokenBalance(input) {
     return queryClient.fetchQuery({
       queryKey: buildQueryKey(newInput?.params),
       queryFn: async () => {
-        if (!newInput || !newInput.getBearerToken || !newInput.params) throw new Error("Input is required");
+        if (!newInput || !newInput.getBearerToken || !newInput.params)
+          throw new Error("Input is required");
         const bearerToken = await newInput.getBearerToken();
         if (!bearerToken) throw new Error("Bearer token is required");
         return chipiSDK.getTokenBalance(newInput.params, bearerToken);
@@ -1018,10 +1026,7 @@ function useCreateSessionKey() {
 function useAddSessionKeyToContract() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation({
-    mutationFn: (input) => chipiSDK.sessions.addSessionKeyToContract(
-      input.params,
-      input.bearerToken
-    )
+    mutationFn: (input) => chipiSDK.sessions.addSessionKeyToContract(input.params, input.bearerToken)
   });
   return {
     addSessionKeyToContract: mutation.mutate,
@@ -1053,11 +1058,7 @@ function useRevokeSessionKey() {
 function useGetSessionData(params, options) {
   const { chipiSDK } = useChipiContext();
   const query = useQuery({
-    queryKey: [
-      "sessionData",
-      params?.walletAddress,
-      params?.sessionPublicKey
-    ],
+    queryKey: ["sessionData", params?.walletAddress, params?.sessionPublicKey],
     queryFn: () => {
       if (!params) {
         throw new Error("Session data params are required");