@chipi-stack/chipi-react 12.2.0 → 12.4.0

package/dist/index.js

@@ -4,6 +4,7 @@ var React = require('react');
 var reactQuery = require('@tanstack/react-query');
 var backend = require('@chipi-stack/backend');
 var jsxRuntime = require('react/jsx-runtime');
+var chipiPasskey = require('@chipi-stack/chipi-passkey');
 var shared = require('@chipi-stack/shared');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -53,10 +54,34 @@ function useChipiContext() {
 function useCreateWallet() {
   const { chipiSDK } = useChipiContext();
   const mutation = reactQuery.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 chipiPasskey.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,
@@ -476,17 +501,91 @@ function useChipiSession(config) {
     error: combinedError
   };
 }
+function useMigrateWalletToPasskey() {
+  const { chipiSDK } = useChipiContext();
+  const mutation = reactQuery.useMutation({
+    mutationFn: async (input) => {
+      const { wallet, oldEncryptKey, externalUserId, bearerToken } = input;
+      try {
+        const passkeyResult = await chipiPasskey.createWalletPasskey(
+          externalUserId,
+          externalUserId
+          // Using externalUserId as userName
+        );
+        let decryptedPrivateKey;
+        try {
+          decryptedPrivateKey = backend.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 = backend.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 = reactQuery.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 chipiPasskey.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 {
@@ -503,13 +602,31 @@ function useTransfer() {
 function useApprove() {
   const { chipiSDK } = useChipiContext();
   const mutation = reactQuery.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 chipiPasskey.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,
@@ -724,13 +841,33 @@ function useGetSku(input) {
 function useStakeVesuUsdc() {
   const { chipiSDK } = useChipiContext();
   const mutation = reactQuery.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 chipiPasskey.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,
@@ -746,13 +883,33 @@ function useStakeVesuUsdc() {
 function useWithdrawVesuUsdc() {
   const { chipiSDK } = useChipiContext();
   const mutation = reactQuery.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 chipiPasskey.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,
@@ -768,7 +925,32 @@ function useWithdrawVesuUsdc() {
 function useCallAnyContract() {
   const { chipiSDK } = useChipiContext();
   const mutation = reactQuery.useMutation({
-    mutationFn: (params) => chipiSDK.callAnyContract(params)
+    mutationFn: async (params) => {
+      let encryptKey = params.params.encryptKey;
+      if (params.params.usePasskey) {
+        try {
+          const key = await chipiPasskey.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,
@@ -1049,6 +1231,7 @@ exports.useGetTokenBalance = useGetTokenBalance;
 exports.useGetTransactionList = useGetTransactionList;
 exports.useGetUser = useGetUser;
 exports.useGetWallet = useGetWallet;
+exports.useMigrateWalletToPasskey = useMigrateWalletToPasskey;
 exports.useRecordSendTransaction = useRecordSendTransaction;
 exports.useRevokeSessionKey = useRevokeSessionKey;
 exports.useStakeVesuUsdc = useStakeVesuUsdc;