@chipi-stack/chipi-react 12.1.0 → 12.3.0

package/dist/hooks.mjs

@@ -1,7 +1,8 @@
 import { useMutation, useQueryClient, useQuery } from '@tanstack/react-query';
 import { createContext, useMemo, useCallback, useState, useEffect, useContext } from 'react';
-import '@chipi-stack/backend';
+import { decryptPrivateKey, encryptPrivateKey } from '@chipi-stack/backend';
 import 'react/jsx-runtime';
+import { createWalletPasskey, getWalletEncryptKey } from '@chipi-stack/chipi-passkey';
 import { ChipiApiError } from '@chipi-stack/shared';
 
 // src/hooks/useCreateWallet.ts
@@ -13,15 +14,37 @@ function useChipiContext() {
   }
   return context;
 }
-
-// src/hooks/useCreateWallet.ts
 function useCreateWallet() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation({
-    mutationFn: (input) => chipiSDK.createWallet({
-      params: input.params,
-      bearerToken: input.bearerToken
-    })
+    mutationFn: async (input) => {
+      let encryptKey = input.params.encryptKey;
+      if (input.params.usePasskey) {
+        if (!input.params.externalUserId) {
+          throw new Error("externalUserId is required when using passkey");
+        }
+        try {
+          const passkeyResult = await createWalletPasskey(
+            input.params.externalUserId,
+            input.params.externalUserId
+            // Using externalUserId as userName
+          );
+          encryptKey = passkeyResult.encryptKey;
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new Error(`Passkey creation failed: ${error.message}`);
+          }
+          throw new Error("Failed to create passkey for wallet");
+        }
+      }
+      return chipiSDK.createWallet({
+        params: {
+          ...input.params,
+          encryptKey
+        },
+        bearerToken: input.bearerToken
+      });
+    }
   });
   return {
     createWallet: mutation.mutate,
@@ -441,17 +464,91 @@ function useChipiSession(config) {
     error: combinedError
   };
 }
+function useMigrateWalletToPasskey() {
+  const { chipiSDK } = useChipiContext();
+  const mutation = useMutation({
+    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) {
+          throw new Error(
+            "Failed to decrypt wallet with provided encryptKey. Please verify your PIN/password is correct."
+          );
+        }
+        const newEncryptedPrivateKey = encryptPrivateKey(
+          decryptedPrivateKey,
+          passkeyResult.encryptKey
+        );
+        const updatedWallet = {
+          ...wallet,
+          encryptedPrivateKey: newEncryptedPrivateKey
+        };
+        return {
+          success: true,
+          wallet: updatedWallet,
+          credentialId: passkeyResult.credentialId
+        };
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(`Migration failed: ${error.message}`);
+        }
+        throw new Error("Failed to migrate wallet to passkey");
+      }
+    }
+  });
+  return {
+    migrateWalletToPasskey: mutation.mutate,
+    migrateWalletToPasskeyAsync: mutation.mutateAsync,
+    data: mutation.data,
+    isLoading: mutation.isPending,
+    isError: mutation.isError,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+    reset: mutation.reset
+  };
+}
 function useTransfer() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation(
     {
-      mutationFn: (input) => chipiSDK.transfer({
-        params: {
-          ...input.params,
-          amount: String(input.params.amount)
-        },
-        bearerToken: input.bearerToken
-      })
+      mutationFn: async (input) => {
+        let encryptKey = input.params.encryptKey;
+        if (input.params.usePasskey) {
+          try {
+            const key = await getWalletEncryptKey();
+            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");
+          }
+        }
+        return chipiSDK.transfer({
+          params: {
+            ...input.params,
+            amount: String(input.params.amount),
+            encryptKey
+          },
+          bearerToken: input.bearerToken
+        });
+      }
     }
   );
   return {
@@ -468,13 +565,31 @@ function useTransfer() {
 function useApprove() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation({
-    mutationFn: (params) => chipiSDK.approve({
-      params: {
-        ...params.params,
-        amount: String(params.params.amount)
-      },
-      bearerToken: params.bearerToken
-    })
+    mutationFn: async (params) => {
+      let encryptKey = params.params.encryptKey;
+      if (params.params.usePasskey) {
+        try {
+          const key = await getWalletEncryptKey();
+          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");
+        }
+      }
+      return chipiSDK.approve({
+        params: {
+          ...params.params,
+          amount: String(params.params.amount),
+          encryptKey
+        },
+        bearerToken: params.bearerToken
+      });
+    }
   });
   return {
     approve: mutation.mutate,
@@ -689,13 +804,33 @@ function useGetSku(input) {
 function useStakeVesuUsdc() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation({
-    mutationFn: (params) => chipiSDK.stakeVesuUsdc({
-      params: {
-        ...params.params,
-        amount: String(params.params.amount)
-      },
-      bearerToken: params.bearerToken
-    })
+    mutationFn: async (params) => {
+      let encryptKey = params.params.encryptKey;
+      if (params.params.usePasskey) {
+        try {
+          const key = await getWalletEncryptKey();
+          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");
+        }
+      }
+      return chipiSDK.stakeVesuUsdc({
+        params: {
+          ...params.params,
+          amount: String(params.params.amount),
+          encryptKey
+        },
+        bearerToken: params.bearerToken
+      });
+    }
   });
   return {
     stakeVesuUsdc: mutation.mutate,
@@ -711,13 +846,33 @@ function useStakeVesuUsdc() {
 function useWithdrawVesuUsdc() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation({
-    mutationFn: (params) => chipiSDK.withdrawVesuUsdc({
-      params: {
-        ...params.params,
-        amount: String(params.params.amount)
-      },
-      bearerToken: params.bearerToken
-    })
+    mutationFn: async (params) => {
+      let encryptKey = params.params.encryptKey;
+      if (params.params.usePasskey) {
+        try {
+          const key = await getWalletEncryptKey();
+          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");
+        }
+      }
+      return chipiSDK.withdrawVesuUsdc({
+        params: {
+          ...params.params,
+          amount: String(params.params.amount),
+          encryptKey
+        },
+        bearerToken: params.bearerToken
+      });
+    }
   });
   return {
     withdrawVesuUsdc: mutation.mutate,
@@ -733,7 +888,32 @@ function useWithdrawVesuUsdc() {
 function useCallAnyContract() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation({
-    mutationFn: (params) => chipiSDK.callAnyContract(params)
+    mutationFn: async (params) => {
+      let encryptKey = params.params.encryptKey;
+      if (params.params.usePasskey) {
+        try {
+          const key = await getWalletEncryptKey();
+          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");
+        }
+      }
+      return chipiSDK.callAnyContract({
+        params: {
+          ...params.params,
+          encryptKey
+        },
+        bearerToken: params.bearerToken
+      });
+    }
   });
   return {
     callAnyContract: mutation.mutate,
@@ -994,6 +1174,6 @@ function useExecuteWithSession() {
   };
 }
 
-export { useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateSkuTransaction, useCreateUser, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuTransaction, useGetTokenBalance, useGetTransactionList, useGetUser, useGetWallet, useRecordSendTransaction, useRevokeSessionKey, useStakeVesuUsdc, useTransfer, useWithdrawVesuUsdc };
+export { useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateSkuTransaction, useCreateUser, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuTransaction, useGetTokenBalance, useGetTransactionList, useGetUser, useGetWallet, useMigrateWalletToPasskey, useRecordSendTransaction, useRevokeSessionKey, useStakeVesuUsdc, useTransfer, useWithdrawVesuUsdc };
 //# sourceMappingURL=hooks.mjs.map
 //# sourceMappingURL=hooks.mjs.map