@getpara/react-sdk 1.12.0 → 2.0.0-alpha.10

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

@@ -1,26 +1,63 @@
 "use client";
 import "../../../chunk-MMUBH76A.js";
-import { useWaitForLoginAndSetup } from "./useWaitForLoginAndSetup.js";
-import { useWaitForAccountCreation } from "./useWaitForAccountCreation.js";
-import { useWaitForPasskeyAndCreateWallet } from "./useWaitForPasskeyAndCreateWallet.js";
-import { useCreateUser } from "./useCreateUser.js";
-import { useCheckIfUserExists } from "./useCheckIfUserExists.js";
-import { useInitiateLogin } from "./useInitiateLogin.js";
-import { useLogout } from "./useLogout.js";
-import { useKeepSessionAlive } from "./useKeepSessionAlive.js";
-import { useSignMessage } from "./useSignMessage.js";
-import { useSignTransaction } from "./useSignTransaction.js";
-import { useCreateGuestWallets } from "./useCreateGuestWallets.js";
+import * as actions from "../../actions/index.js";
+import { generateHook, generateStateHook } from "./utils.js";
+const useSignUpOrLogIn = generateHook("signUpOrLogIn", actions.signUpOrLogIn);
+const useVerifyNewAccount = generateHook("verifyNewAccount", actions.verifyNewAccount);
+const useWaitForLogin = generateHook("waitForLogin", actions.waitForLogin);
+const useWaitForSignup = generateHook("waitForSignup", actions.waitForSignup);
+const useWaitForWalletCreation = generateHook("waitForWalletCreation", actions.waitForWalletCreation);
+const useVerifyOAuth = generateHook("verifyOAuth", actions.verifyOAuth);
+const useVerifyFarcaster = generateHook("verifyFarcaster", actions.verifyFarcaster);
+const useVerifyTelegram = generateHook("verifyTelegram", actions.verifyTelegram);
+const useLoginExternalWallet = generateHook("loginExternalWallet", actions.loginExternalWallet);
+const useVerifyExternalWallet = generateHook("verifyExternalWallet", actions.verifyExternalWallet);
+const useSetup2fa = generateHook("setup2fa", actions.setup2fa);
+const useEnable2fa = generateHook("enable2fa", actions.enable2fa);
+const useVerify2fa = generateHook("verify2fa", actions.verify2fa);
+const useKeepSessionAlive = generateHook("keepSessionAlive", actions.keepSessionAlive);
+const useLogout = generateHook("logout", actions.logout);
+const useResendVerificationCode = generateHook("resendVerificationCode", actions.resendVerificationCode);
+const useCreateWallet = generateHook("createWallet", actions.createWallet);
+const useCreateWalletPerType = generateHook("createWalletPerType", actions.createWalletPerType);
+const useCreatePregenWallet = generateHook("createPregenWallet", actions.createPregenWallet);
+const useCreatePregenWalletPerType = generateHook("createPregenWalletPerType", actions.createPregenWalletPerType);
+const useClaimPregenWallets = generateHook("claimPregenWallets", actions.claimPregenWallets);
+const useHasPregenWallet = generateHook("hasPregenWallet", actions.hasPregenWallet);
+const useUpdatePregenWalletIdentifier = generateHook(
+  "updatePregenWalletIdentifier",
+  actions.updatePregenWalletIdentifier
+);
+const useCreateGuestWallets = generateHook("createGuestWallets", actions.createGuestWallets);
+const useSignMessage = generateHook("signMessage", actions.signMessage);
+const useSignTransaction = generateHook("signTransaction", actions.signTransaction);
+const useCreateGuestWalletsState = generateStateHook("createGuestWallets");
 export {
-  useCheckIfUserExists,
+  useClaimPregenWallets,
   useCreateGuestWallets,
-  useCreateUser,
-  useInitiateLogin,
+  useCreateGuestWalletsState,
+  useCreatePregenWallet,
+  useCreatePregenWalletPerType,
+  useCreateWallet,
+  useCreateWalletPerType,
+  useEnable2fa,
+  useHasPregenWallet,
   useKeepSessionAlive,
+  useLoginExternalWallet,
   useLogout,
+  useResendVerificationCode,
+  useSetup2fa,
   useSignMessage,
   useSignTransaction,
-  useWaitForAccountCreation,
-  useWaitForLoginAndSetup,
-  useWaitForPasskeyAndCreateWallet
+  useSignUpOrLogIn,
+  useUpdatePregenWalletIdentifier,
+  useVerify2fa,
+  useVerifyExternalWallet,
+  useVerifyFarcaster,
+  useVerifyNewAccount,
+  useVerifyOAuth,
+  useVerifyTelegram,
+  useWaitForLogin,
+  useWaitForSignup,
+  useWaitForWalletCreation
 };

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

@@ -0,0 +1,5 @@
+import { CoreMethodName, CoreMethodParams, CoreMethods } from '@getpara/web-sdk';
+import { CoreMethodHook, CoreMethodStateHook } from '../../types/utils.js';
+import { CoreAction } from '../../actions/utils.js';
+export declare function generateHook<const method extends CoreMethodName & keyof CoreMethods>(method: method, action: CoreAction<method>, defaultParams?: CoreMethodParams<method>): () => CoreMethodHook<method>;
+export declare function generateStateHook<const method extends CoreMethodName & keyof CoreMethods>(method: method): CoreMethodStateHook<method>;

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

@@ -0,0 +1,59 @@
+"use client";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { renameCoreMutations } from "../../utils/renameMutations.js";
+import { useClient } from "../utils/index.js";
+import { useMutation, useMutationState } from "@tanstack/react-query";
+function generateHook(method, action, defaultParams) {
+  return () => {
+    const para = useClient();
+    const mutation = useMutation({
+      mutationKey: [method],
+      mutationFn: (args) => __async(this, null, function* () {
+        const result = yield action(para, args != null ? args : defaultParams);
+        return result;
+      })
+    });
+    return renameCoreMutations(mutation, method);
+  };
+}
+function generateStateHook(method) {
+  return () => {
+    const frames = useMutationState({
+      filters: { mutationKey: [method] },
+      select: (mutation) => mutation.state
+    });
+    const latest = frames[frames.length - 1];
+    if (!latest) {
+      return {
+        data: void 0,
+        error: null,
+        failureCount: 0,
+        isLoading: false,
+        isPaused: false,
+        isPending: false,
+        isError: false,
+        isSuccess: false,
+        isIdle: true,
+        status: "idle",
+        variables: void 0,
+        context: null,
+        failureReason: null,
+        submittedAt: 0
+      };
+    }
+    return __spreadProps(__spreadValues({}, latest), {
+      isPending: latest.status === "pending",
+      isError: latest.status === "error",
+      isSuccess: latest.status === "success",
+      isIdle: latest.status === "idle"
+    });
+  };
+}
+export {
+  generateHook,
+  generateStateHook
+};

package/dist/provider/hooks/queries/useAccount.d.ts

@@ -2,10 +2,4 @@ export declare const ACCOUNT_BASE_KEY = "PARA_ACCOUNT";
 /**
  * Hook for retrieving a user account
  */
-export declare const useAccount: () => import("@tanstack/react-query").UseQueryResult<{
-    isConnected: boolean;
-    isGuestMode: boolean;
-    email: any;
-    phone: any;
-    wallets: any;
-}, Error>;
+export declare const useAccount: () => import("@tanstack/react-query").UseQueryResult<import("../../actions/getAccount.js").Account, Error>;

package/dist/provider/hooks/queries/useWallet.d.ts

@@ -2,4 +2,4 @@ export declare const WALLET_BASE_KEY = "PARA_WALLET";
 /**
  * Hook for retrieving the selected wallet
  */
-export declare const useWallet: () => import("@tanstack/react-query").UseQueryResult<Omit<import("@getpara/core-sdk").Wallet, "signer">, Error>;
+export declare const useWallet: () => import("@tanstack/react-query").UseQueryResult<Omit<import("@getpara/core-sdk").Wallet, "signer"> | null | undefined, Error>;

package/dist/provider/hooks/queries/useWalletBalance.d.ts

@@ -1,7 +1,6 @@
-import { UseQueryOptions } from '@tanstack/react-query';
 import { GetWalletBalanceParams } from '@getpara/web-sdk';
 export declare const WALLET_BALANCE_BASE_KEY = "PARA_WALLET_BALANCE";
 /**
  * Hook for retrieving a wallet balance
  */
-export declare const useWalletBalance: (args?: Partial<GetWalletBalanceParams>, queryOptions?: Pick<UseQueryOptions, "refetchInterval">) => import("@tanstack/react-query").UseQueryResult<unknown, Error>;
+export declare const useWalletBalance: (args?: Partial<GetWalletBalanceParams>) => import("@tanstack/react-query").UseQueryResult<string | null, Error>;

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

@@ -4,21 +4,50 @@ import {
   __spreadValues
 } from "../../../chunk-MMUBH76A.js";
 import { useQuery } from "@tanstack/react-query";
-import { useClient, useWalletState } from "../index.js";
-import { getWalletBalance } from "../../actions/getWalletBalance.js";
+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, queryOptions) => {
+const useWalletBalance = (args) => {
   const client = useClient();
-  const { selectedWallet } = useWalletState();
+  const { data: selectedWallet } = useWallet();
+  const {
+    selectedWallet: { type: selectedWalletType }
+  } = useWalletState();
+  const { data: account } = useAccount();
   const rpcUrl = useStore((state) => state.rpcUrl);
-  const completeArgs = __spreadValues({ walletId: selectedWallet.id, rpcUrl }, args);
-  return useQuery(__spreadValues({
-    queryKey: [WALLET_BALANCE_BASE_KEY, client == null ? void 0 : client.getUserId(), completeArgs],
-    queryFn: () => __async(void 0, null, function* () {
-      return yield getWalletBalance(client, completeArgs);
-    })
-  }, queryOptions));
+  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,

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

@@ -18,7 +18,7 @@ const useAutoSessionKeepAlive = ({ disabled }) => {
       clearSessionMonitoring();
       return;
     }
-    if ((account == null ? void 0 : account.isConnected) && !client.isUsingExternalWallet()) {
+    if ((account == null ? void 0 : account.isConnected) && !account.isGuestMode && client.externalWalletConnectionType !== "CONNECTION_ONLY") {
       setupSessionMonitoring();
     } else {
       clearSessionMonitoring();
@@ -27,7 +27,7 @@ const useAutoSessionKeepAlive = ({ disabled }) => {
   }, [client, account, disabled]);
   const getSessionExpiry = () => __async(void 0, null, function* () {
     try {
-      const sessionCookie = yield client.retrieveSessionCookie();
+      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;
@@ -40,13 +40,13 @@ const useAutoSessionKeepAlive = ({ disabled }) => {
     sessionCheckInterval.current = setInterval(() => __async(void 0, null, function* () {
       const expiry = yield getSessionExpiry();
       if (!expiry) {
-        yield logoutAsync();
+        yield logoutAsync({});
         clearSessionMonitoring();
         return;
       }
       const timeUntilExpiry = expiry.getTime() - Date.now();
       if (timeUntilExpiry <= 0) {
-        yield logoutAsync();
+        yield logoutAsync({});
         clearSessionMonitoring();
         return;
       }
@@ -56,7 +56,7 @@ const useAutoSessionKeepAlive = ({ disabled }) => {
           setupSessionMonitoring();
         } catch (err) {
           console.error("Failed to keep session alive:", err);
-          yield logoutAsync();
+          yield logoutAsync({});
           clearSessionMonitoring();
         }
         return;

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

@@ -1,14 +1,14 @@
 "use client";
 import "../../../chunk-MMUBH76A.js";
 import { useQueryClient } from "@tanstack/react-query";
-import { useEffect } from "react";
-import { useClient, useWalletState } from "../index.js";
+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 "../../hooks/queries/useWallet.js";
+import { WALLET_BASE_KEY } from "../queries/useWallet.js";
 const useEventListeners = ({
   onLogin,
   onLogout,
@@ -19,62 +19,92 @@ const useEventListeners = ({
   onWalletCreated,
   onPregenWalletClaimed,
   onExternalWalletChange,
-  onWalletsChange
+  onWalletsChange,
+  onGuestWalletsCreated
 } = {}) => {
   const queryClient = useQueryClient();
-  const client = useClient();
   const clearSelectedWallet = useStore((state) => state.clearSelectedWallet);
-  const { selectedWallet, setSelectedWallet } = useWalletState();
-  const loginListener = (event) => {
-    loginOrSetupListener();
-    onLogin == null ? void 0 : onLogin(event);
-  };
-  const accountSetupListener = (event) => {
-    loginOrSetupListener();
-    onAccountSetup == null ? void 0 : onAccountSetup(event);
-  };
-  const loginOrSetupListener = () => {
-    queryClient.invalidateQueries({ queryKey: [ACCOUNT_BASE_KEY], exact: false });
-    queryClient.invalidateQueries({ queryKey: [WALLET_BASE_KEY], exact: false });
-  };
-  const accountCreationListener = (event) => {
-    onAccountCreation == null ? void 0 : onAccountCreation(event);
-  };
-  const logoutListener = (event) => {
-    queryClient.invalidateQueries({ queryKey: [ACCOUNT_BASE_KEY], exact: false });
-    clearSelectedWallet();
-    onLogout == null ? void 0 : onLogout(event);
-  };
-  const signMessageListener = (event) => {
-    onSignMessage == null ? void 0 : onSignMessage(event);
-  };
-  const signTransactionListener = (event) => {
-    onSignTransaction == null ? void 0 : onSignTransaction(event);
-  };
-  const walletChangeListener = (event) => {
-    updateSelectedWallet();
-    onWalletsChange == null ? void 0 : onWalletsChange(event);
-  };
-  const externalWalletChangeListener = (event) => {
-    updateSelectedWallet();
-    onExternalWalletChange == null ? void 0 : onExternalWalletChange(event);
-  };
-  const walletCreatedListener = (event) => {
-    onWalletCreated == null ? void 0 : onWalletCreated(event);
-  };
-  const pregenWalletClaimedListener = (event) => {
-    onPregenWalletClaimed == null ? void 0 : onPregenWalletClaimed(event);
-  };
-  const updateSelectedWallet = () => {
-    if (!client) {
+  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();
-      return;
-    }
-    if (!(selectedWallet == null ? void 0 : selectedWallet.id) || !client.findWallet(selectedWallet == null ? void 0 : selectedWallet.id)) {
-      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 });
-    }
-  };
+      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) => {
+      queryClient.refetchQueries({ queryKey: [ACCOUNT_BASE_KEY] });
+      updateSelectedWallet();
+      onGuestWalletsCreated == null ? void 0 : onGuestWalletsCreated(event);
+    },
+    [onGuestWalletsCreated]
+  );
   useEffect(() => {
     window.addEventListener(ParaEvent.LOGIN_EVENT, loginListener);
     window.addEventListener(ParaEvent.ACCOUNT_SETUP_EVENT, accountSetupListener);
@@ -86,6 +116,7 @@ const useEventListeners = ({
     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);
@@ -97,8 +128,21 @@ const useEventListeners = ({
       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);
     };
-  }, [client]);
+  }, [
+    loginListener,
+    accountSetupListener,
+    accountCreationListener,
+    logoutListener,
+    signMessageListener,
+    signTransactionListener,
+    walletChangeListener,
+    externalWalletChangeListener,
+    walletCreatedListener,
+    pregenWalletClaimedListener,
+    guestWalletsCreatedListener
+  ]);
 };
 export {
   useEventListeners

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

@@ -1,14 +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;
-        type: WalletType;
+        id: string | 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

@@ -2,30 +2,45 @@
 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 = ({ id, type }) => {
-    try {
-      const validId = client.findWalletId(id, { type: [type] });
-      if (validId !== id) {
+  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();
-      } else {
-        setStoredSelectedWallet(id, type);
       }
-    } catch (e) {
+    },
+    [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
+    setSelectedWallet,
+    updateSelectedWallet
   };
 };
 export {

package/dist/provider/index.d.ts

@@ -1,3 +1,4 @@
 export { ParaProvider } from './ParaProvider.js';
 export * from './hooks/index.js';
 export * from './stores/getters.js';
+export * from './stores/setters.js';

package/dist/provider/index.js

@@ -3,6 +3,7 @@ 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

@@ -0,0 +1,35 @@
+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 } from '@getpara/user-management-client';
+type Value = {
+    signUpOrLogIn: (_: VerifiedAuth) => void;
+    isSignUpOrLogInPending: boolean;
+    verifyNewAccount: (_: string) => void;
+    isVerifyNewAccountPending: boolean;
+    verifyNewAccountError: Error | null;
+    verifyOAuth: (_: CoreMethodParams<'verifyOAuth'>['method']) => void;
+    verifyFarcaster: () => void;
+    verifyTelegram: (_: TelegramAuthResponse) => void;
+    onNewAuthState: (_: AuthState) => void;
+    presentSignupUi: (_: AuthMethod, __: AuthStateSignup) => void;
+    presentLoginUi: (_: AuthMethod, __: AuthStateLogin) => void;
+    isSetup2faPending: boolean;
+    createGuestWallets: () => void;
+    isCreateGuestWalletsPending: boolean;
+    logout: () => void;
+    biometricHints?: BiometricHints;
+};
+type Props = PropsWithChildren<{
+    is2faEnabled?: boolean;
+    isRecoverySecretStepEnabled?: boolean;
+    overrides?: {
+        login?: ParaModalProps['loginTransitionOverride'];
+        createWallets?: ParaModalProps['createWalletOverride'];
+    };
+}>;
+export declare const AuthContext: import("react").Context<Value>;
+export declare function AuthProvider({ children, is2faEnabled, isRecoverySecretStepEnabled, overrides, }: Props): import("react/jsx-runtime").JSX.Element;
+export declare const useAuthActions: () => Value;
+export {};