@chipi-stack/chipi-react 11.22.0 → 12.1.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import React, { createContext, useContext } from 'react';
+import React, { createContext, useContext, useMemo, useCallback, useState, useEffect } from 'react';
 import { QueryClient, QueryClientProvider, useMutation, useQueryClient, useQuery } from '@tanstack/react-query';
 import { ChipiSDK } from '@chipi-stack/backend';
 import { jsx } from 'react/jsx-runtime';
@@ -109,6 +109,367 @@ function useGetWallet(input) {
     fetchWallet
   };
 }
+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 walletQuery = useQuery({
+    queryKey: ["chipi-wallet", externalUserId],
+    queryFn: async () => {
+      if (!externalUserId) return null;
+      const bearerToken = await getBearerToken();
+      if (!bearerToken) throw new Error("Bearer token is required");
+      return chipiSDK.getWallet({ externalUserId }, bearerToken);
+    },
+    enabled: isEnabled,
+    retry: (failureCount, error) => {
+      if (error instanceof ChipiApiError || error?.status) {
+        return false;
+      }
+      return failureCount < 3;
+    }
+  });
+  const walletPublicKey = walletQuery.data?.wallet.publicKey;
+  const balanceQuery = useQuery({
+    queryKey: ["chipi-wallet-balance", walletPublicKey, defaultToken],
+    queryFn: async () => {
+      if (!walletPublicKey) throw new Error("No wallet");
+      const bearerToken = await getBearerToken();
+      if (!bearerToken) throw new Error("Bearer token is required");
+      return chipiSDK.getTokenBalance(
+        {
+          chain: "STARKNET",
+          chainToken: defaultToken,
+          walletPublicKey
+        },
+        bearerToken
+      );
+    },
+    enabled: Boolean(walletPublicKey),
+    retry: (failureCount, error) => {
+      if (error instanceof ChipiApiError || error?.status) {
+        return false;
+      }
+      return failureCount < 3;
+    }
+  });
+  const createWalletMutation = useMutation({
+    mutationFn: async ({ encryptKey, walletType = "CHIPI" }) => {
+      if (!externalUserId) 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: {
+          encryptKey,
+          externalUserId,
+          walletType
+        },
+        bearerToken
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["chipi-wallet", externalUserId]
+      });
+    }
+  });
+  const wallet = useMemo(() => {
+    if (walletQuery.isLoading) return void 0;
+    if (!walletQuery.data) return null;
+    const data = walletQuery.data;
+    return {
+      ...data,
+      supportsSessionKeys: data.wallet.walletType === "CHIPI",
+      shortAddress: formatAddress(data.wallet.publicKey)
+    };
+  }, [walletQuery.data, walletQuery.isLoading]);
+  const formattedBalance = useMemo(() => {
+    if (!balanceQuery.data?.balance) return "0.00";
+    const num = Number(balanceQuery.data.balance);
+    return num.toLocaleString(void 0, {
+      minimumFractionDigits: 2,
+      maximumFractionDigits: defaultToken === "ETH" || defaultToken === "STRK" ? 6 : 2
+    });
+  }, [balanceQuery.data, defaultToken]);
+  const refetchWallet = useCallback(async () => {
+    await walletQuery.refetch();
+  }, [walletQuery]);
+  const refetchBalance = useCallback(async () => {
+    await balanceQuery.refetch();
+  }, [balanceQuery]);
+  const refetchAll = useCallback(async () => {
+    await Promise.all([walletQuery.refetch(), balanceQuery.refetch()]);
+  }, [walletQuery, balanceQuery]);
+  const createWallet = useCallback(
+    async (params) => {
+      return createWalletMutation.mutateAsync(params);
+    },
+    [createWalletMutation]
+  );
+  return {
+    // Wallet data
+    wallet,
+    hasWallet: wallet !== null && wallet !== void 0,
+    isLoadingWallet: walletQuery.isLoading,
+    walletError: walletQuery.error,
+    // Balance data
+    balance: balanceQuery.data,
+    formattedBalance,
+    isLoadingBalance: balanceQuery.isLoading,
+    // Create wallet
+    createWallet,
+    isCreating: createWalletMutation.isPending,
+    createdWallet: createWalletMutation.data,
+    // Actions
+    refetchWallet,
+    refetchBalance,
+    refetchAll
+  };
+}
+function formatAddress(address, chars = 6) {
+  if (!address || address.length < chars * 2) return address;
+  return `${address.slice(0, chars + 2)}...${address.slice(-chars)}`;
+}
+function useChipiSession(config) {
+  const { chipiSDK } = useChipiContext();
+  const queryClient = useQueryClient();
+  const {
+    wallet,
+    encryptKey,
+    getBearerToken,
+    storedSession,
+    onSessionCreated,
+    defaultDurationSeconds = 21600,
+    // 6 hours
+    defaultMaxCalls = 1e3,
+    autoCheckStatus = true
+  } = config;
+  const [localSession, setLocalSession] = useState(
+    storedSession ?? null
+  );
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (storedSession) {
+      setLocalSession(storedSession);
+    }
+  }, [storedSession]);
+  const supportsSession = useMemo(() => {
+    if (!wallet) return false;
+    return wallet.walletType === "CHIPI";
+  }, [wallet]);
+  const sessionStatusQuery = useQuery({
+    queryKey: ["chipi-session-status", wallet?.publicKey, localSession?.publicKey],
+    queryFn: async () => {
+      if (!wallet?.publicKey || !localSession?.publicKey) return null;
+      return chipiSDK.sessions.getSessionData({
+        walletAddress: wallet.publicKey,
+        sessionPublicKey: localSession.publicKey
+      });
+    },
+    enabled: Boolean(
+      autoCheckStatus && wallet?.publicKey && localSession?.publicKey && supportsSession
+    ),
+    staleTime: 3e4
+    // 30 seconds
+  });
+  const sessionState = useMemo(() => {
+    if (!localSession) return "none";
+    const status = sessionStatusQuery.data;
+    if (status) {
+      if (!status.isActive) return "revoked";
+      if (status.validUntil * 1e3 < Date.now()) return "expired";
+      if (status.remainingCalls <= 0) return "expired";
+      return "active";
+    }
+    if (localSession.validUntil * 1e3 < Date.now()) return "expired";
+    return "created";
+  }, [localSession, 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.");
+      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);
+    }
+  });
+  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");
+      if (!supportsSession) throw new Error("Wallet does not support sessions");
+      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;
+    },
+    onSuccess: () => {
+      setError(null);
+      queryClient.invalidateQueries({
+        queryKey: ["chipi-session-status", wallet?.publicKey, localSession?.publicKey]
+      });
+    },
+    onError: (err) => {
+      setError(err);
+    }
+  });
+  const revokeSessionMutation = useMutation({
+    mutationFn: async () => {
+      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");
+      if (!supportsSession) throw new Error("Wallet does not support sessions");
+      const bearerToken = await getBearerToken();
+      if (!bearerToken) throw new Error("Bearer token is required");
+      const txHash = await chipiSDK.sessions.revokeSessionKey(
+        {
+          encryptKey,
+          wallet,
+          sessionPublicKey: localSession.publicKey
+        },
+        bearerToken
+      );
+      return txHash;
+    },
+    onSuccess: () => {
+      setError(null);
+      queryClient.invalidateQueries({
+        queryKey: ["chipi-session-status", wallet?.publicKey, localSession?.publicKey]
+      });
+    },
+    onError: (err) => {
+      setError(err);
+    }
+  });
+  const executeWithSessionMutation = useMutation({
+    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 bearerToken = await getBearerToken();
+      if (!bearerToken) throw new Error("Bearer token is required");
+      const txHash = await chipiSDK.executeTransactionWithSession({
+        params: {
+          encryptKey,
+          wallet,
+          session: localSession,
+          calls
+        },
+        bearerToken
+      });
+      return txHash;
+    },
+    onSuccess: () => {
+      setError(null);
+      queryClient.invalidateQueries({
+        queryKey: ["chipi-session-status", wallet?.publicKey, localSession?.publicKey]
+      });
+    },
+    onError: (err) => {
+      setError(err);
+    }
+  });
+  const createSession = useCallback(
+    async (params) => {
+      return createSessionMutation.mutateAsync(params ?? {});
+    },
+    [createSessionMutation]
+  );
+  const registerSession = useCallback(
+    async (sessionConfig) => {
+      return registerSessionMutation.mutateAsync(sessionConfig ?? {});
+    },
+    [registerSessionMutation]
+  );
+  const revokeSession = useCallback(async () => {
+    return revokeSessionMutation.mutateAsync();
+  }, [revokeSessionMutation]);
+  const executeWithSession = useCallback(
+    async (calls) => {
+      return executeWithSessionMutation.mutateAsync(calls);
+    },
+    [executeWithSessionMutation]
+  );
+  const clearSession = useCallback(() => {
+    setLocalSession(null);
+    setError(null);
+  }, []);
+  const refetchStatus = useCallback(async () => {
+    await sessionStatusQuery.refetch();
+  }, [sessionStatusQuery]);
+  const combinedError = useMemo(() => {
+    return error || createSessionMutation.error || registerSessionMutation.error || revokeSessionMutation.error || executeWithSessionMutation.error || sessionStatusQuery.error || null;
+  }, [
+    error,
+    createSessionMutation.error,
+    registerSessionMutation.error,
+    revokeSessionMutation.error,
+    executeWithSessionMutation.error,
+    sessionStatusQuery.error
+  ]);
+  return {
+    // Session data
+    session: localSession,
+    sessionStatus: sessionStatusQuery.data ?? void 0,
+    sessionState,
+    hasActiveSession,
+    isSessionExpired,
+    remainingCalls,
+    supportsSession,
+    // Actions
+    createSession,
+    registerSession,
+    revokeSession,
+    executeWithSession,
+    clearSession,
+    refetchStatus,
+    // Loading states
+    isCreating: createSessionMutation.isPending,
+    isRegistering: registerSessionMutation.isPending,
+    isRevoking: revokeSessionMutation.isPending,
+    isExecuting: executeWithSessionMutation.isPending,
+    isLoadingStatus: sessionStatusQuery.isLoading,
+    // Errors
+    error: combinedError
+  };
+}
 function useTransfer() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation(
@@ -436,8 +797,15 @@ function useRecordSendTransaction() {
 function useGetTokenBalance(input) {
   const { chipiSDK } = useChipiContext();
   const queryClient = useQueryClient();
+  const buildQueryKey = (params) => [
+    "chain-token-balance",
+    params?.chainToken ?? null,
+    params?.chain ?? null,
+    params?.walletPublicKey ?? null,
+    params?.externalUserId ?? null
+  ];
   const query = useQuery({
-    queryKey: ["chain-token-balance", input?.params?.chainToken, input?.params?.chain, input?.params?.walletPublicKey, input?.params?.externalUserId],
+    queryKey: buildQueryKey(input?.params),
     queryFn: async () => {
       if (!input || !input.params || !input.getBearerToken) throw new Error("Input is required");
       const bearerToken = await input.getBearerToken();
@@ -445,17 +813,17 @@ function useGetTokenBalance(input) {
       return chipiSDK.getTokenBalance(input.params, bearerToken);
     },
     enabled: Boolean(input?.params && input?.getBearerToken),
-    ...input?.queryOptions,
     retry: (failureCount, error) => {
       if (error instanceof ChipiApiError || error?.status) {
         return false;
       }
       return failureCount < 3;
-    }
+    },
+    ...input?.queryOptions
   });
   const fetchTokenBalance = async (newInput) => {
     return queryClient.fetchQuery({
-      queryKey: ["chain-token-balance", newInput?.params?.chainToken, newInput?.params?.chain, newInput?.params?.walletPublicKey, newInput?.params?.externalUserId],
+      queryKey: buildQueryKey(newInput?.params),
       queryFn: async () => {
         if (!newInput || !newInput.getBearerToken || !newInput.params) throw new Error("Input is required");
         const bearerToken = await newInput.getBearerToken();
@@ -559,7 +927,102 @@ function useCreateUser() {
     reset: mutation.reset
   };
 }
+function useCreateSessionKey() {
+  const { chipiSDK } = useChipiContext();
+  const mutation = useMutation({
+    mutationFn: async (params) => chipiSDK.sessions.createSessionKey(params)
+  });
+  return {
+    createSessionKey: mutation.mutate,
+    createSessionKeyAsync: mutation.mutateAsync,
+    data: mutation.data,
+    isLoading: mutation.isPending,
+    isError: mutation.isError,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+    reset: mutation.reset
+  };
+}
+function useAddSessionKeyToContract() {
+  const { chipiSDK } = useChipiContext();
+  const mutation = useMutation({
+    mutationFn: (input) => chipiSDK.sessions.addSessionKeyToContract(
+      input.params,
+      input.bearerToken
+    )
+  });
+  return {
+    addSessionKeyToContract: mutation.mutate,
+    addSessionKeyToContractAsync: mutation.mutateAsync,
+    data: mutation.data,
+    isLoading: mutation.isPending,
+    isError: mutation.isError,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+    reset: mutation.reset
+  };
+}
+function useRevokeSessionKey() {
+  const { chipiSDK } = useChipiContext();
+  const mutation = useMutation({
+    mutationFn: (input) => chipiSDK.sessions.revokeSessionKey(input.params, input.bearerToken)
+  });
+  return {
+    revokeSessionKey: mutation.mutate,
+    revokeSessionKeyAsync: mutation.mutateAsync,
+    data: mutation.data,
+    isLoading: mutation.isPending,
+    isError: mutation.isError,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+    reset: mutation.reset
+  };
+}
+function useGetSessionData(params, options) {
+  const { chipiSDK } = useChipiContext();
+  const query = useQuery({
+    queryKey: [
+      "sessionData",
+      params?.walletAddress,
+      params?.sessionPublicKey
+    ],
+    queryFn: () => {
+      if (!params) {
+        throw new Error("Session data params are required");
+      }
+      return chipiSDK.sessions.getSessionData(params);
+    },
+    enabled: options?.enabled !== false && params !== null
+  });
+  return {
+    data: query.data,
+    isLoading: query.isLoading,
+    isError: query.isError,
+    error: query.error,
+    isSuccess: query.isSuccess,
+    refetch: query.refetch
+  };
+}
+function useExecuteWithSession() {
+  const { chipiSDK } = useChipiContext();
+  const mutation = useMutation({
+    mutationFn: (input) => chipiSDK.executeTransactionWithSession({
+      params: input.params,
+      bearerToken: input.bearerToken
+    })
+  });
+  return {
+    executeWithSession: mutation.mutate,
+    executeWithSessionAsync: mutation.mutateAsync,
+    data: mutation.data,
+    isLoading: mutation.isPending,
+    isError: mutation.isError,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+    reset: mutation.reset
+  };
+}
 
-export { ChipiProvider, useApprove, useCallAnyContract, useChipiContext, useCreateSkuTransaction, useCreateUser, useCreateWallet, useGetSku, useGetSkuList, useGetSkuTransaction, useGetTokenBalance, useGetTransactionList, useGetUser, useGetWallet, useRecordSendTransaction, useStakeVesuUsdc, useTransfer, useWithdrawVesuUsdc };
+export { ChipiProvider, useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiContext, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateSkuTransaction, useCreateUser, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuTransaction, useGetTokenBalance, useGetTransactionList, useGetUser, useGetWallet, useRecordSendTransaction, useRevokeSessionKey, useStakeVesuUsdc, useTransfer, useWithdrawVesuUsdc };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map