@getpara/react-sdk 2.0.0-alpha.3 → 2.0.0-alpha.6

package/dist/provider/hooks/queries/useWalletBalance.js

@@ -0,0 +1,55 @@
+"use client";
+import {
+  __async,
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useAccount, useClient, useWallet, useWalletState } from "../index.js";
+import { useStore } from "../../stores/useStore.js";
+import { getWalletBalance } from "../../actions/index.js";
+import { useExternalWallets } from "../../providers/ExternalWalletProvider.js";
+import { useCallback } from "react";
+const WALLET_BALANCE_BASE_KEY = "PARA_WALLET_BALANCE";
+const useWalletBalance = (args) => {
+  const client = useClient();
+  const { data: selectedWallet } = useWallet();
+  const {
+    selectedWallet: { type: selectedWalletType }
+  } = useWalletState();
+  const { data: account } = useAccount();
+  const rpcUrl = useStore((state) => state.rpcUrl);
+  const { getWalletBalance: getExternalWalletBalance, chainId } = useExternalWallets();
+  const queryFn = useCallback(() => __async(void 0, null, function* () {
+    var _a, _b, _c;
+    const skipGetBalance = !selectedWallet || selectedWalletType && ["COSMOS", "SOLANA"].includes(selectedWalletType);
+    if (skipGetBalance) {
+      return null;
+    }
+    try {
+      if (selectedWallet.isExternal) {
+        return (_a = yield getExternalWalletBalance()) != null ? _a : null;
+      } else {
+        const completeArgs = __spreadValues({ walletId: (_b = selectedWallet == null ? void 0 : selectedWallet.id) != null ? _b : "", rpcUrl }, args);
+        return (_c = yield getWalletBalance(client, completeArgs)) != null ? _c : null;
+      }
+    } catch (err) {
+      console.error("Error fetching wallet balance: ", err);
+      return null;
+    }
+  }), [account, selectedWallet, selectedWalletType, rpcUrl, getExternalWalletBalance]);
+  return useQuery({
+    queryKey: [
+      WALLET_BALANCE_BASE_KEY,
+      client == null ? void 0 : client.userId,
+      selectedWallet == null ? void 0 : selectedWallet.id,
+      selectedWallet == null ? void 0 : selectedWallet.type,
+      (selectedWallet == null ? void 0 : selectedWallet.isExternal) ? chainId : ""
+    ],
+    queryFn,
+    enabled: !!selectedWallet && !!rpcUrl && !!(account == null ? void 0 : account.isConnected)
+  });
+};
+export {
+  WALLET_BALANCE_BASE_KEY,
+  useWalletBalance
+};

package/dist/provider/hooks/utils/index.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useClient } from "./useClient.js";
+import { useModal } from "./useModal.js";
+import { useWalletState } from "./useWalletState.js";
+export {
+  useClient,
+  useModal,
+  useWalletState
+};

package/dist/provider/hooks/utils/useAutoSessionKeepAlive.js

@@ -0,0 +1,74 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useEffect, useRef } from "react";
+import { useAccount, useKeepSessionAlive, useLogout } from "../index.js";
+import { useInternalClient } from "./useInternalClient.js";
+const SESSION_CHECK_INTERVAL = 6e4;
+const SESSION_REFRESH_THRESHOLD = 3e5;
+const useAutoSessionKeepAlive = ({ disabled }) => {
+  const client = useInternalClient();
+  const { data: account } = useAccount();
+  const { logoutAsync } = useLogout();
+  const { keepSessionAliveAsync } = useKeepSessionAlive();
+  const sessionCheckInterval = useRef(null);
+  useEffect(() => {
+    if (!client || disabled) {
+      clearSessionMonitoring();
+      return;
+    }
+    if ((account == null ? void 0 : account.isConnected) && !account.isGuestMode && client.externalWalletConnectionType !== "CONNECTION_ONLY") {
+      setupSessionMonitoring();
+    } else {
+      clearSessionMonitoring();
+    }
+    return () => clearSessionMonitoring();
+  }, [client, account, disabled]);
+  const getSessionExpiry = () => __async(void 0, null, function* () {
+    try {
+      const sessionCookie = yield client == null ? void 0 : client.retrieveSessionCookie();
+      if (!sessionCookie) return null;
+      const expiresMatch = sessionCookie.match(/Expires=([^;]+)/);
+      return expiresMatch ? new Date(expiresMatch[1]) : null;
+    } catch (err) {
+      return null;
+    }
+  });
+  const setupSessionMonitoring = () => {
+    clearSessionMonitoring();
+    sessionCheckInterval.current = setInterval(() => __async(void 0, null, function* () {
+      const expiry = yield getSessionExpiry();
+      if (!expiry) {
+        yield logoutAsync({});
+        clearSessionMonitoring();
+        return;
+      }
+      const timeUntilExpiry = expiry.getTime() - Date.now();
+      if (timeUntilExpiry <= 0) {
+        yield logoutAsync({});
+        clearSessionMonitoring();
+        return;
+      }
+      if (timeUntilExpiry <= SESSION_REFRESH_THRESHOLD) {
+        try {
+          yield keepSessionAliveAsync();
+          setupSessionMonitoring();
+        } catch (err) {
+          console.error("Failed to keep session alive:", err);
+          yield logoutAsync({});
+          clearSessionMonitoring();
+        }
+        return;
+      }
+    }), SESSION_CHECK_INTERVAL);
+  };
+  const clearSessionMonitoring = () => {
+    if (sessionCheckInterval.current) {
+      clearInterval(sessionCheckInterval.current);
+    }
+  };
+};
+export {
+  useAutoSessionKeepAlive
+};

package/dist/provider/hooks/utils/useClient.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useStore } from "../../stores/useStore.js";
+const useClient = () => {
+  const client = useStore((state) => state.client);
+  return client;
+};
+export {
+  useClient
+};

package/dist/provider/hooks/utils/useEventListeners.d.ts

@@ -1,2 +1,2 @@
 import { Callbacks } from '../../types/provider.js';
-export declare const useEventListeners: ({ onLogin, onLogout, onAccountSetup, onAccountCreation, onSignMessage, onSignTransaction, onWalletCreated, onPregenWalletClaimed, onExternalWalletChange, onWalletsChange, }?: Callbacks) => void;
+export declare const useEventListeners: ({ onLogin, onLogout, onAccountSetup, onAccountCreation, onSignMessage, onSignTransaction, onWalletCreated, onPregenWalletClaimed, onExternalWalletChange, onWalletsChange, onGuestWalletsCreated, }?: Callbacks) => void;

package/dist/provider/hooks/utils/useEventListeners.js

@@ -0,0 +1,147 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect } from "react";
+import { useWalletState } from "../index.js";
+import {
+  ParaEvent
+} from "@getpara/web-sdk";
+import { ACCOUNT_BASE_KEY } from "../queries/useAccount.js";
+import { useStore } from "../../stores/useStore.js";
+import { WALLET_BASE_KEY } from "../queries/useWallet.js";
+const useEventListeners = ({
+  onLogin,
+  onLogout,
+  onAccountSetup,
+  onAccountCreation,
+  onSignMessage,
+  onSignTransaction,
+  onWalletCreated,
+  onPregenWalletClaimed,
+  onExternalWalletChange,
+  onWalletsChange,
+  onGuestWalletsCreated
+} = {}) => {
+  const queryClient = useQueryClient();
+  const clearSelectedWallet = useStore((state) => state.clearSelectedWallet);
+  const { updateSelectedWallet } = useWalletState();
+  const loginOrSetupListener = useCallback(() => {
+    queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+    queryClient.refetchQueries({ queryKey: [WALLET_BASE_KEY] });
+  }, [queryClient]);
+  const loginListener = useCallback(
+    (event) => {
+      loginOrSetupListener();
+      onLogin == null ? void 0 : onLogin(event);
+    },
+    [loginOrSetupListener, onLogin]
+  );
+  const accountSetupListener = useCallback(
+    (event) => {
+      loginOrSetupListener();
+      onAccountSetup == null ? void 0 : onAccountSetup(event);
+    },
+    [loginOrSetupListener, onAccountSetup]
+  );
+  const accountCreationListener = useCallback(
+    (event) => {
+      onAccountCreation == null ? void 0 : onAccountCreation(event);
+    },
+    [onAccountCreation]
+  );
+  const logoutListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      clearSelectedWallet();
+      onLogout == null ? void 0 : onLogout(event);
+    },
+    [queryClient, clearSelectedWallet, onLogout]
+  );
+  const signMessageListener = useCallback(
+    (event) => {
+      onSignMessage == null ? void 0 : onSignMessage(event);
+    },
+    [onSignMessage]
+  );
+  const signTransactionListener = useCallback(
+    (event) => {
+      onSignTransaction == null ? void 0 : onSignTransaction(event);
+    },
+    [onSignTransaction]
+  );
+  const walletChangeListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      updateSelectedWallet();
+      onWalletsChange == null ? void 0 : onWalletsChange(event);
+    },
+    [queryClient, updateSelectedWallet, onWalletsChange]
+  );
+  const externalWalletChangeListener = useCallback(
+    (event) => {
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      updateSelectedWallet();
+      onExternalWalletChange == null ? void 0 : onExternalWalletChange(event);
+    },
+    [queryClient, updateSelectedWallet, onExternalWalletChange]
+  );
+  const walletCreatedListener = useCallback(
+    (event) => {
+      onWalletCreated == null ? void 0 : onWalletCreated(event);
+    },
+    [onWalletCreated]
+  );
+  const pregenWalletClaimedListener = useCallback(
+    (event) => {
+      onPregenWalletClaimed == null ? void 0 : onPregenWalletClaimed(event);
+    },
+    [onPregenWalletClaimed]
+  );
+  const guestWalletsCreatedListener = useCallback(
+    (event) => {
+      onGuestWalletsCreated == null ? void 0 : onGuestWalletsCreated(event);
+    },
+    [onGuestWalletsCreated]
+  );
+  useEffect(() => {
+    window.addEventListener(ParaEvent.LOGIN_EVENT, loginListener);
+    window.addEventListener(ParaEvent.ACCOUNT_SETUP_EVENT, accountSetupListener);
+    window.addEventListener(ParaEvent.ACCOUNT_CREATION_EVENT, accountCreationListener);
+    window.addEventListener(ParaEvent.LOGOUT_EVENT, logoutListener);
+    window.addEventListener(ParaEvent.SIGN_MESSAGE_EVENT, signMessageListener);
+    window.addEventListener(ParaEvent.SIGN_TRANSACTION_EVENT, signTransactionListener);
+    window.addEventListener(ParaEvent.WALLETS_CHANGE_EVENT, walletChangeListener);
+    window.addEventListener(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, externalWalletChangeListener);
+    window.addEventListener(ParaEvent.WALLET_CREATED, walletCreatedListener);
+    window.addEventListener(ParaEvent.PREGEN_WALLET_CLAIMED, pregenWalletClaimedListener);
+    window.addEventListener(ParaEvent.GUEST_WALLETS_CREATED, guestWalletsCreatedListener);
+    return () => {
+      window.removeEventListener(ParaEvent.LOGIN_EVENT, loginListener);
+      window.removeEventListener(ParaEvent.ACCOUNT_SETUP_EVENT, accountSetupListener);
+      window.removeEventListener(ParaEvent.ACCOUNT_CREATION_EVENT, accountCreationListener);
+      window.removeEventListener(ParaEvent.LOGOUT_EVENT, logoutListener);
+      window.removeEventListener(ParaEvent.SIGN_MESSAGE_EVENT, signMessageListener);
+      window.removeEventListener(ParaEvent.SIGN_TRANSACTION_EVENT, signTransactionListener);
+      window.removeEventListener(ParaEvent.WALLETS_CHANGE_EVENT, walletChangeListener);
+      window.removeEventListener(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, externalWalletChangeListener);
+      window.removeEventListener(ParaEvent.WALLET_CREATED, walletCreatedListener);
+      window.removeEventListener(ParaEvent.PREGEN_WALLET_CLAIMED, pregenWalletClaimedListener);
+      window.removeEventListener(ParaEvent.GUEST_WALLETS_CREATED, guestWalletsCreatedListener);
+    };
+  }, [
+    loginListener,
+    accountSetupListener,
+    accountCreationListener,
+    logoutListener,
+    signMessageListener,
+    signTransactionListener,
+    walletChangeListener,
+    externalWalletChangeListener,
+    walletCreatedListener,
+    pregenWalletClaimedListener,
+    guestWalletsCreatedListener
+  ]);
+};
+export {
+  useEventListeners
+};

package/dist/provider/hooks/utils/useInternalClient.js

@@ -0,0 +1,10 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useStore } from "../../stores/useStore.js";
+const useInternalClient = () => {
+  const client = useStore((state) => state.client);
+  return client;
+};
+export {
+  useInternalClient
+};

package/dist/provider/hooks/utils/useModal.js

@@ -0,0 +1,17 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useStore } from "../../stores/useStore.js";
+const useModal = () => {
+  const isOpen = useStore((state) => state.isOpen);
+  const setIsOpen = useStore((state) => state.setIsOpen);
+  const openModal = () => {
+    setIsOpen(true);
+  };
+  const closeModal = () => {
+    setIsOpen(false);
+  };
+  return { isOpen, openModal, closeModal };
+};
+export {
+  useModal
+};

package/dist/provider/hooks/utils/useWalletState.d.ts

@@ -1,15 +1,15 @@
-import { WalletType } from '@getpara/web-sdk';
+import { TWalletType } from '@getpara/web-sdk';
 /**
  * Hook for controlling selected wallet
  */
 export declare const useWalletState: () => {
     selectedWallet: {
         id: string | undefined;
-        type: WalletType | undefined;
+        type: "EVM" | "SOLANA" | "COSMOS" | undefined;
     };
     setSelectedWallet: ({ id, type }: {
         id?: string;
-        type?: WalletType;
+        type?: TWalletType;
     }) => void;
     updateSelectedWallet: () => void;
 };

package/dist/provider/hooks/utils/useWalletState.js

@@ -0,0 +1,48 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useStore } from "../../stores/useStore.js";
+import { useClient } from "./useClient.js";
+import { useCallback } from "react";
+const useWalletState = () => {
+  const client = useClient();
+  const selectedWalletId = useStore((state) => state.selectedWalletId);
+  const selectedWalletType = useStore((state) => state.selectedWalletType);
+  const setStoredSelectedWallet = useStore((state) => state.setSelectedWallet);
+  const clearSelectedWallet = useStore((state) => state.clearSelectedWallet);
+  const setSelectedWallet = useCallback(
+    ({ id, type }) => {
+      try {
+        const validId = client == null ? void 0 : client.findWalletId(id, type ? { type: [type] } : void 0);
+        if (validId !== id) {
+          clearSelectedWallet();
+        } else {
+          setStoredSelectedWallet(id, type);
+        }
+      } catch (e) {
+        clearSelectedWallet();
+      }
+    },
+    [client, clearSelectedWallet, setStoredSelectedWallet]
+  );
+  const updateSelectedWallet = useCallback(() => {
+    if (!client) {
+      clearSelectedWallet();
+      return;
+    }
+    if (!selectedWalletId || !client.findWallet(selectedWalletId)) {
+      const defaultWallet = client.findWallet(void 0, void 0, { forbidPregen: true });
+      setSelectedWallet({ id: defaultWallet == null ? void 0 : defaultWallet.id, type: defaultWallet == null ? void 0 : defaultWallet.type });
+    }
+  }, [clearSelectedWallet, setSelectedWallet, client, selectedWalletId]);
+  return {
+    selectedWallet: {
+      id: selectedWalletId,
+      type: selectedWalletType
+    },
+    setSelectedWallet,
+    updateSelectedWallet
+  };
+};
+export {
+  useWalletState
+};

package/dist/provider/index.js

@@ -0,0 +1,9 @@
+"use client";
+import "../chunk-MMUBH76A.js";
+import { ParaProvider } from "./ParaProvider.js";
+export * from "./hooks/index.js";
+export * from "./stores/getters.js";
+export * from "./stores/setters.js";
+export {
+  ParaProvider
+};

package/dist/provider/providers/AuthProvider.d.ts

@@ -1,19 +1,23 @@
 import { BiometricHints } from '@getpara/react-common';
 import { PropsWithChildren } from 'react';
 import { AuthMethod, CoreMethodParams, AuthState, AuthStateSignup, AuthStateLogin } from '@getpara/web-sdk';
-import { ParaModalProps } from '../../modal//types/modalProps.js';
-import { TelegramAuthResponse, VerifiedAuth, VerifyExternalWalletParams } from '@getpara/user-management-client';
+import { ParaModalProps } from '../../modal/types/modalProps.js';
+import { TelegramAuthResponse, VerifiedAuth } from '@getpara/user-management-client';
 type Value = {
-    signUpOrLogIn: [(_: VerifiedAuth) => void, boolean];
-    verifyNewAccount: [(_: string) => void, boolean, Error | null];
+    signUpOrLogIn: (_: VerifiedAuth) => void;
+    isSignUpOrLogInPending: boolean;
+    verifyNewAccount: (_: string) => void;
+    isVerifyNewAccountPending: boolean;
+    verifyNewAccountError: Error | null;
     verifyOAuth: (_: CoreMethodParams<'verifyOAuth'>['method']) => void;
     verifyFarcaster: () => void;
     verifyTelegram: (_: TelegramAuthResponse) => void;
-    verifyExternalWallet: (_: VerifyExternalWalletParams) => void;
     onNewAuthState: (_: AuthState) => void;
     presentSignupUi: (_: AuthMethod, __: AuthStateSignup) => void;
     presentLoginUi: (_: AuthMethod, __: AuthStateLogin) => void;
-    setup2fa: [boolean];
+    isSetup2faPending: boolean;
+    createGuestWallets: () => void;
+    isCreateGuestWalletsPending: boolean;
     logout: () => void;
     biometricHints?: BiometricHints;
 };