@getpara/react-sdk 2.0.0-alpha.3 → 2.0.0-dev.1

package/dist/modal/components/BiometricCreationStep/BiometricCreationStep.d.ts

@@ -1 +1 @@
-export declare const BiometricCreationStep: () => import("react/jsx-runtime").JSX.Element | null;
+export declare const BiometricCreationStep: () => import("react/jsx-runtime").JSX.Element;

package/dist/modal/components/BiometricLoginStep/BiometricLoginStep.d.ts

@@ -1 +1 @@
-export declare const BiometricLoginStep: () => import("react/jsx-runtime").JSX.Element | null;
+export declare const BiometricLoginStep: () => import("react/jsx-runtime").JSX.Element;

package/dist/modal/components/ModalContent/ModalContent.d.ts

@@ -1,5 +1,9 @@
 import { ParaModalProps } from '../../types/modalProps.js';
+import { useCreateAccount } from '../../hooks/useCreateAccount.js';
 type ModalContentProps = Omit<ParaModalProps, 'para' | 'isOpen' | 'theme' | 'branding' | 'onModalStepChange' | 'onExpandModalChange'>;
+export declare const ActionsContext: import("react").Context<{
+    createAccount: ReturnType<typeof useCreateAccount>;
+}>;
 export type ModalContentHandle = {
     /**
      * Trigger the modal close handler

package/dist/modal/hooks/useCreateAccount.d.ts

@@ -0,0 +1,4 @@
+export declare function useCreateAccount(): {
+    withPasskey: () => void;
+    withPassword: () => void;
+};

package/dist/modal/index.d.ts

@@ -6,4 +6,3 @@ export * from './utils/openPopup.js';
 export { ON_RAMP_PROVIDERS, ON_RAMP_ASSETS, NETWORKS, getAssetIcon, getAssetName, getNetworkIcon, getNetworkName, } from './constants/constants.js';
 export { SaveRecoverySecret } from './components/RecoverySecretStep/RecoverySecretStep.js';
 export * from './utils/validateOnRampConfig.js';
-export * from './types/externalWallets.js';

package/dist/modal/stores/index.d.ts

@@ -1 +1,2 @@
 export * from './modal/useModalStore.js';
+export * from './userInfo/useUserInfoStore.js';

package/dist/modal/stores/modal/useModalStore.d.ts

@@ -1,10 +1,10 @@
 import { ModalStep } from '../../utils/steps.js';
 import { OnRampConfig as OnRampConfigBase, OnRampPurchase, WalletType } from '@getpara/web-sdk';
 import { Tab as AddFundsTabType } from '../../components/AddFunds/AddFunds.js';
-import { AuthStateLogin, AuthStateSignup, AuthState, AuthStateVerify } from '@getpara/core-sdk';
+import { AuthStateLogin, AuthStateSignup, AuthMethod, AuthState, AuthStateVerify } from '@getpara/core-sdk';
 import { TAuthLayout } from '../../types/modalProps.js';
 import { MutableRefObject } from 'react';
-import { Setup2faResponse } from '@getpara/user-management-client';
+import { BiometricLocationHint, Setup2faResponse } from '@getpara/user-management-client';
 type Flow = AuthStateSignup['stage'] | AuthStateLogin['stage'] | 'account';
 type ActiveWallet = [string | undefined, WalletType | undefined];
 export type OnRampConfig = OnRampConfigBase & {
@@ -16,11 +16,14 @@ export interface OnModalStepChangeValue {
     canGoBack: boolean;
 }
 interface ModalState {
-    recoveryShare: string | null;
     step: ModalStep;
     stepDirection: 1 | -1;
     flow: Flow | undefined;
     authState: AuthState | undefined;
+    webAuthURLForLogin: string | undefined;
+    webAuthURLForCreate: string | undefined;
+    passwordUrlForLogin: string | undefined;
+    supportedAuthMethods: Set<AuthMethod>;
     onModalStepChange?: (value: OnModalStepChangeValue) => void | undefined;
     onRampConfig: OnRampConfig | undefined;
     onRampPurchase: Partial<OnRampPurchase> | undefined;
@@ -33,6 +36,7 @@ interface ModalState {
     activeWallet: ActiveWallet | undefined;
     farcasterConnectUri: string | undefined;
     twoFactorStatus: Setup2faResponse | undefined;
+    biometricLocationHints: BiometricLocationHint[] | undefined;
     iFrameUrl: string | undefined;
     isIFrameReady: boolean | undefined;
     authLayout?: TAuthLayout[];
@@ -49,7 +53,6 @@ interface ModalState {
 }
 export interface ModalActions {
     resetState: () => void;
-    setRecoveryShare: (recoveryShare: string | null) => void;
     setStep: (step: ModalStep) => void;
     decrementStep: () => void;
     hasPreviousStep: () => boolean;
@@ -60,6 +63,10 @@ export interface ModalActions {
     getLoginState: () => AuthStateLogin | undefined;
     isLogin: () => boolean;
     isAccount: () => boolean;
+    setSupportedAuthMethods: (authMethods: Set<AuthMethod>) => void;
+    setWebAuthURLForLogin: (url?: string) => void;
+    setWebAuthURLForCreate: (url?: string) => void;
+    setPasswordUrlForLogin: (url?: string) => void;
     setOnModalStepChange: (fn?: (value: OnModalStepChangeValue) => void) => void;
     setOnRampConfig: (_: OnRampConfig | undefined) => void;
     setOnRampPurchase: (_: Partial<OnRampPurchase> | undefined) => void;
@@ -72,6 +79,7 @@ export interface ModalActions {
     setStepDirection: (stepDirection: 1 | -1) => void;
     setFarcasterConnectUri: (_: string | undefined) => void;
     setTwoFactorStatus: (twoFactorStatus?: Setup2faResponse) => void;
+    setBiometricLocationHints: (_?: BiometricLocationHint[]) => void;
     setIFrameUrl: (_?: string) => void;
     setIsIFrameReady: (_?: boolean) => void;
     setAuthLayout: (authLayout: TAuthLayout[]) => void;

package/dist/modal/stores/userInfo/actions.d.ts

@@ -0,0 +1,3 @@
+import { StoreApi } from 'zustand';
+import { UserInfoActions, UserInfoStore } from './useUserInfoStore.js';
+export declare const getActions: (set: StoreApi<UserInfoStore>["setState"], get: StoreApi<UserInfoStore>["getState"]) => UserInfoActions;

package/dist/modal/stores/userInfo/useUserInfoStore.d.ts

@@ -0,0 +1,19 @@
+import { PrimaryAuth } from '@getpara/user-management-client';
+import { ModalAuthInfo } from '@getpara/react-common';
+type SetAuthInfo = PrimaryAuth & Partial<Pick<ModalAuthInfo, 'pfpUrl' | 'displayName'>>;
+type UserInfoState = {
+    auth: PrimaryAuth | null;
+    pfpUrl: string | null;
+    displayName: string | null;
+    recoveryShare: string | null;
+};
+export interface UserInfoActions {
+    resetState: () => void;
+    setAuthInfo: (auth: SetAuthInfo) => void;
+    getAuthInfo: () => ModalAuthInfo | null;
+    setRecoveryShare: (recoveryShare: string | null) => void;
+}
+export type UserInfoStore = UserInfoState & UserInfoActions;
+export declare const DEFAULT_USER_INFO_STATE: UserInfoState;
+export declare const useUserInfoStore: import("zustand").UseBoundStore<import("zustand").StoreApi<UserInfoStore>>;
+export {};

package/dist/modal/types/commonTypes.d.ts

@@ -1,51 +1,4 @@
 import { IconType } from '@getpara/react-components';
-import { AuthStateLogin, AuthStateVerify, WalletType } from '@getpara/web-sdk';
-export type WalletMetadata = {
-    id: string;
-    name: string;
-    iconUrl: string;
-    installed?: boolean;
-    isExtension?: boolean;
-    isMobile?: boolean;
-    isWeb?: boolean;
-    downloadUrl?: string;
-    getQrUri?: () => Promise<string>;
-    downloadUrls?: {
-        android?: string;
-        ios?: string;
-        mobile?: string;
-        qrCode?: string;
-        chrome?: string;
-        edge?: string;
-        firefox?: string;
-        opera?: string;
-        safari?: string;
-        browserExtension?: string;
-        macos?: string;
-        windows?: string;
-        linux?: string;
-        desktop?: string;
-    };
-};
-export type CommonWallet = {
-    connect: () => Promise<{
-        address?: string;
-        bufferAddress?: string;
-        error?: string;
-        authState?: AuthStateVerify | AuthStateLogin;
-    }>;
-    connectMobile: (isManualWalletConnect?: boolean) => Promise<{
-        address?: string;
-        bufferAddress?: string;
-        error?: string;
-        authState?: AuthStateVerify | AuthStateLogin;
-    }>;
-    type: WalletType;
-} & WalletMetadata;
-export type CommonChain = {
-    id: string | number;
-    name: string;
-};
 export type Tab<T> = {
     label: string;
     value: T;

package/dist/provider/actions/checkIfUserExists.d.ts

@@ -0,0 +1,4 @@
+import ParaWeb from '@getpara/web-sdk';
+import { Auth } from '@getpara/user-management-client';
+export type CheckIfUserExistsArgs = Auth<'email'> | Auth<'phone'>;
+export declare const checkIfUserExists: (para?: ParaWeb, args?: CheckIfUserExistsArgs) => Promise<boolean>;

package/dist/provider/actions/createUser.d.ts

@@ -0,0 +1,4 @@
+import { Auth } from '@getpara/user-management-client';
+import ParaWeb from '@getpara/web-sdk';
+export type CreateUserArgs = Auth<'email'> | Auth<'phone'>;
+export declare const createUser: (para?: ParaWeb, args?: CreateUserArgs) => Promise<void>;

package/dist/provider/actions/getAccount.d.ts

@@ -1,19 +1,10 @@
-import ParaWeb, { CoreAuthInfo } from '@getpara/web-sdk';
-type AccountValue = CoreAuthInfo & {
+import ParaWeb, { Wallet } from '@getpara/web-sdk';
+type AccountType = {
+    isConnected: boolean;
     email?: string;
-    phone?: `+${number}`;
-    farcasterUsername?: string;
-    telegramUserId?: string;
-    externalWalletAddress?: string;
-    wallets: (typeof ParaWeb.prototype)['availableWallets'];
-    userId: string;
+    phone?: string;
+    wallets?: Pick<Wallet, 'id' | 'type' | 'name' | 'address' | 'isExternal'>[];
+    userId?: string;
 };
-export type Account = ({
-    isConnected: false;
-} & {
-    [key in keyof AccountValue]?: undefined;
-}) | ({
-    isConnected: true;
-} & AccountValue);
-export declare const getAccount: (para?: ParaWeb) => Promise<Account>;
+export declare const getAccount: (para?: ParaWeb) => Promise<AccountType>;
 export {};

package/dist/provider/actions/index.d.ts

@@ -1,25 +1,25 @@
-export declare const signUpOrLogIn: import("./utils.js").CoreAction<"signUpOrLogIn">;
-export declare const verifyNewAccount: import("./utils.js").CoreAction<"verifyNewAccount">;
-export declare const waitForLogin: import("./utils.js").CoreAction<"waitForLogin">;
-export declare const waitForSignup: import("./utils.js").CoreAction<"waitForSignup">;
-export declare const waitForWalletCreation: import("./utils.js").CoreAction<"waitForWalletCreation">;
-export declare const verifyOAuth: import("./utils.js").CoreAction<"verifyOAuth">;
-export declare const verifyFarcaster: import("./utils.js").CoreAction<"verifyFarcaster">;
-export declare const verifyTelegram: import("./utils.js").CoreAction<"verifyTelegram">;
-export declare const loginExternalWallet: import("./utils.js").CoreAction<"loginExternalWallet">;
-export declare const verifyExternalWallet: import("./utils.js").CoreAction<"verifyExternalWallet">;
-export declare const setup2fa: import("./utils.js").CoreAction<"setup2fa">;
-export declare const enable2fa: import("./utils.js").CoreAction<"enable2fa">;
-export declare const verify2fa: import("./utils.js").CoreAction<"verify2fa">;
+export declare const signUpOrLogIn: import("./utils.js").CoreAction<"signUpOrLogInV2">;
+export declare const verifyNewAccount: import("./utils.js").CoreAction<"verifyNewAccountV2">;
+export declare const waitForLogin: import("./utils.js").CoreAction<"waitForLoginV2">;
+export declare const waitForSignup: import("./utils.js").CoreAction<"waitForSignupV2">;
+export declare const waitForWalletCreation: import("./utils.js").CoreAction<"waitForWalletCreationV2">;
+export declare const verifyOAuth: import("./utils.js").CoreAction<"verifyOAuthV2">;
+export declare const verifyFarcaster: import("./utils.js").CoreAction<"verifyFarcasterV2">;
+export declare const verifyTelegram: import("./utils.js").CoreAction<"verifyTelegramV2">;
+export declare const loginExternalWallet: import("./utils.js").CoreAction<"loginExternalWalletV2">;
+export declare const verifyExternalWallet: import("./utils.js").CoreAction<"verifyExternalWalletV2">;
+export declare const setup2fa: import("./utils.js").CoreAction<"setup2faV2">;
+export declare const enable2fa: import("./utils.js").CoreAction<"enable2faV2">;
+export declare const verify2fa: import("./utils.js").CoreAction<"verify2faV2">;
 export declare const keepSessionAlive: import("./utils.js").CoreAction<"keepSessionAlive">;
 export declare const logout: import("./utils.js").CoreAction<"logout">;
 export declare const resendVerificationCode: import("./utils.js").CoreAction<"resendVerificationCode">;
 export declare const createWallet: import("./utils.js").CoreAction<"createWallet">;
 export declare const createWalletPerType: import("./utils.js").CoreAction<"createWalletPerType">;
-export declare const createPregenWallet: import("./utils.js").CoreAction<"createPregenWallet">;
-export declare const createPregenWalletPerType: import("./utils.js").CoreAction<"createPregenWalletPerType">;
-export declare const claimPregenWallets: import("./utils.js").CoreAction<"claimPregenWallets">;
-export declare const hasPregenWallet: import("./utils.js").CoreAction<"hasPregenWallet">;
-export declare const updatePregenWalletIdentifier: import("./utils.js").CoreAction<"updatePregenWalletIdentifier">;
+export declare const createPregenWallet: import("./utils.js").CoreAction<"createPregenWalletV2">;
+export declare const createPregenWalletPerType: import("./utils.js").CoreAction<"createPregenWalletPerTypeV2">;
+export declare const claimPregenWallets: import("./utils.js").CoreAction<"claimPregenWalletsV2">;
+export declare const hasPregenWallet: import("./utils.js").CoreAction<"hasPregenWalletV2">;
+export declare const updatePregenWalletIdentifier: import("./utils.js").CoreAction<"updatePregenWalletIdentifierV2">;
 export declare const signMessage: import("./utils.js").CoreAction<"signMessage">;
 export declare const signTransaction: import("./utils.js").CoreAction<"signTransaction">;

package/dist/provider/actions/initiateLogin.d.ts

@@ -0,0 +1,4 @@
+import { PrimaryAuth } from '@getpara/user-management-client';
+import ParaWeb from '@getpara/web-sdk';
+export type InitiateLoginArgs = PrimaryAuth;
+export declare const initiateLogin: (para?: ParaWeb, args?: InitiateLoginArgs) => Promise<Set<import("@getpara/user-management-client").AuthMethod>>;

package/dist/provider/actions/keepSessionAlive.d.ts

@@ -0,0 +1,2 @@
+import ParaWeb from '@getpara/web-sdk';
+export declare const keepSessionAlive: (para?: ParaWeb) => Promise<void>;

package/dist/provider/actions/logout.d.ts

@@ -0,0 +1,5 @@
+import ParaWeb from '@getpara/web-sdk';
+export interface LogoutArgs {
+    clearPregenWallets?: boolean;
+}
+export declare const logout: (para?: ParaWeb, args?: LogoutArgs) => Promise<void>;

package/dist/provider/actions/signMessage.d.ts

@@ -0,0 +1,8 @@
+import ParaWeb from '@getpara/web-sdk';
+export interface SignMessageArgs {
+    walletId: string;
+    messageBase64: string;
+    timeoutMs?: number;
+    cosmosSignDocBase64?: string;
+}
+export declare const signMessage: (para?: ParaWeb, args?: SignMessageArgs) => Promise<import("@getpara/web-sdk").FullSignatureRes>;

package/dist/provider/actions/signTransaction.d.ts

@@ -0,0 +1,8 @@
+import ParaWeb from '@getpara/web-sdk';
+export interface SignTransactionArgs {
+    walletId: string;
+    rlpEncodedTxBase64: string;
+    chainId: string;
+    timeoutMs?: number;
+}
+export declare const signTransaction: (para?: ParaWeb, args?: SignTransactionArgs) => Promise<import("@getpara/web-sdk").FullSignatureRes>;

package/dist/provider/actions/waitForAccountCreation.d.ts

@@ -0,0 +1,5 @@
+import ParaWeb from '@getpara/web-sdk';
+export interface waitForAccountCreationArgs {
+    popupWindow?: Window | null;
+}
+export declare const waitForAccountCreation: (para?: ParaWeb, args?: waitForAccountCreationArgs) => Promise<true>;

package/dist/provider/actions/waitForLoginAndSetup.d.ts

@@ -0,0 +1,6 @@
+import ParaWeb from '@getpara/web-sdk';
+export interface WaitForLoginAndSetupArgs {
+    popupWindow?: Window | null;
+    skipSessionRefresh?: boolean;
+}
+export declare const waitForLoginAndSetup: (para?: ParaWeb, args?: WaitForLoginAndSetupArgs) => Promise<import("@getpara/web-sdk").LoginResponse>;

package/dist/provider/actions/waitForPasskeyAndCreateWallet.d.ts

@@ -0,0 +1,2 @@
+import ParaWeb from '@getpara/web-sdk';
+export declare const waitForPasskeyAndCreateWallet: (para?: ParaWeb) => Promise<import("@getpara/web-sdk").AccountSetupResponse>;

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

@@ -1,25 +1,34 @@
-export declare const useSignUpOrLogIn: () => import("../../types/utils.js").CoreMethodHook<"signUpOrLogIn">;
-export declare const useVerifyNewAccount: () => import("../../types/utils.js").CoreMethodHook<"verifyNewAccount">;
-export declare const useWaitForLogin: () => import("../../types/utils.js").CoreMethodHook<"waitForLogin">;
-export declare const useWaitForSignup: () => import("../../types/utils.js").CoreMethodHook<"waitForSignup">;
-export declare const useWaitForWalletCreation: () => import("../../types/utils.js").CoreMethodHook<"waitForWalletCreation">;
-export declare const useVerifyOAuth: () => import("../../types/utils.js").CoreMethodHook<"verifyOAuth">;
-export declare const useVerifyFarcaster: () => import("../../types/utils.js").CoreMethodHook<"verifyFarcaster">;
-export declare const useVerifyTelegram: () => import("../../types/utils.js").CoreMethodHook<"verifyTelegram">;
-export declare const useLoginExternalWallet: () => import("../../types/utils.js").CoreMethodHook<"loginExternalWallet">;
-export declare const useVerifyExternalWallet: () => import("../../types/utils.js").CoreMethodHook<"verifyExternalWallet">;
-export declare const useSetup2fa: () => import("../../types/utils.js").CoreMethodHook<"setup2fa">;
-export declare const useEnable2fa: () => import("../../types/utils.js").CoreMethodHook<"enable2fa">;
-export declare const useVerify2fa: () => import("../../types/utils.js").CoreMethodHook<"verify2fa">;
-export declare const useKeepSessionAlive: () => import("../../types/utils.js").CoreMethodHook<"keepSessionAlive">;
+export { useWaitForLoginAndSetup } from './useWaitForLoginAndSetup.js';
+export { useWaitForAccountCreation } from './useWaitForAccountCreation.js';
+export { useWaitForPasskeyAndCreateWallet } from './useWaitForPasskeyAndCreateWallet.js';
+export { useCreateUser } from './useCreateUser.js';
+export { useCheckIfUserExists } from './useCheckIfUserExists.js';
+export { useInitiateLogin } from './useInitiateLogin.js';
+export { useKeepSessionAlive } from './useKeepSessionAlive.js';
+export { useSignMessage } from './useSignMessage.js';
+export { useSignTransaction } from './useSignTransaction.js';
+export declare const useSignUpOrLogIn: () => import("../../types/utils.js").CoreMethodHook<"signUpOrLogInV2">;
+export declare const useVerifyNewAccount: () => import("../../types/utils.js").CoreMethodHook<"verifyNewAccountV2">;
+export declare const useWaitForLogin: () => import("../../types/utils.js").CoreMethodHook<"waitForLoginV2">;
+export declare const useWaitForSignup: () => import("../../types/utils.js").CoreMethodHook<"waitForSignupV2">;
+export declare const useWaitForWalletCreation: () => import("../../types/utils.js").CoreMethodHook<"waitForWalletCreationV2">;
+export declare const useVerifyOAuth: () => import("../../types/utils.js").CoreMethodHook<"verifyOAuthV2">;
+export declare const useVerifyFarcaster: () => import("../../types/utils.js").CoreMethodHook<"verifyFarcasterV2">;
+export declare const useVerifyTelegram: () => import("../../types/utils.js").CoreMethodHook<"verifyTelegramV2">;
+export declare const useLoginExternalWallet: () => import("../../types/utils.js").CoreMethodHook<"loginExternalWalletV2">;
+export declare const useVerifyExternalWallet: () => import("../../types/utils.js").CoreMethodHook<"verifyExternalWalletV2">;
+export declare const useSetup2fa: () => import("../../types/utils.js").CoreMethodHook<"setup2faV2">;
+export declare const useEnable2fa: () => import("../../types/utils.js").CoreMethodHook<"enable2faV2">;
+export declare const useVerify2fa: () => import("../../types/utils.js").CoreMethodHook<"verify2faV2">;
+export declare const useKeepSessionAliveV2: () => import("../../types/utils.js").CoreMethodHook<"keepSessionAlive">;
 export declare const useLogout: () => import("../../types/utils.js").CoreMethodHook<"logout">;
 export declare const useResendVerificationCode: () => import("../../types/utils.js").CoreMethodHook<"resendVerificationCode">;
 export declare const useCreateWallet: () => import("../../types/utils.js").CoreMethodHook<"createWallet">;
 export declare const useCreateWalletPerType: () => import("../../types/utils.js").CoreMethodHook<"createWalletPerType">;
-export declare const useCreatePregenWallet: () => import("../../types/utils.js").CoreMethodHook<"createPregenWallet">;
-export declare const useCreatePregenWalletPerType: () => import("../../types/utils.js").CoreMethodHook<"createPregenWalletPerType">;
-export declare const useClaimPregenWallets: () => import("../../types/utils.js").CoreMethodHook<"claimPregenWallets">;
-export declare const useHasPregenWallet: () => import("../../types/utils.js").CoreMethodHook<"hasPregenWallet">;
-export declare const useUpdatePregenWalletIdentifier: () => import("../../types/utils.js").CoreMethodHook<"updatePregenWalletIdentifier">;
-export declare const useSignMessage: () => import("../../types/utils.js").CoreMethodHook<"signMessage">;
-export declare const useSignTransaction: () => import("../../types/utils.js").CoreMethodHook<"signTransaction">;
+export declare const useCreatePregenWallet: () => import("../../types/utils.js").CoreMethodHook<"createPregenWalletV2">;
+export declare const useCreatePregenWalletPerType: () => import("../../types/utils.js").CoreMethodHook<"createPregenWalletPerTypeV2">;
+export declare const useClaimPregenWallets: () => import("../../types/utils.js").CoreMethodHook<"claimPregenWalletsV2">;
+export declare const useHasPregenWallet: () => import("../../types/utils.js").CoreMethodHook<"hasPregenWalletV2">;
+export declare const useUpdatePregenWalletIdentifier: () => import("../../types/utils.js").CoreMethodHook<"updatePregenWalletIdentifierV2">;
+export declare const useSignMessageV2: () => import("../../types/utils.js").CoreMethodHook<"signMessage">;
+export declare const useSignTransactionV2: () => import("../../types/utils.js").CoreMethodHook<"signTransaction">;

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

@@ -0,0 +1,13 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { CheckIfUserExistsArgs } from '../../actions/checkIfUserExists.js';
+import { Compute } from '../../types/utils.js';
+import { UseMutationReturnType } from '../../types/query.js';
+type UseCheckIfUserExistsReturnType<TData = boolean, TError = Error, TVariables = CheckIfUserExistsArgs, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    checkIfUserExists: UseMutateFunction<TData, TError, TVariables, TContext>;
+    checkIfUserExistsAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for checking is a user exists
+ */
+export declare const useCheckIfUserExists: () => UseCheckIfUserExistsReturnType<boolean, Error, CheckIfUserExistsArgs, unknown>;
+export {};

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

@@ -0,0 +1,13 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { CreateUserArgs } from '../../actions/createUser.js';
+import { Compute } from '../../types/utils.js';
+import { UseMutationReturnType } from '../../types/query.js';
+type UseCreateUserReturnType<TData = void, TError = Error, TVariables = CreateUserArgs, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    createUser: UseMutateFunction<TData, TError, TVariables, TContext>;
+    createUserAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for creating a new user
+ */
+export declare const useCreateUser: () => UseCreateUserReturnType<void, Error, CreateUserArgs, unknown>;
+export {};

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

@@ -0,0 +1,14 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { InitiateLoginArgs } from '../../actions/initiateLogin.js';
+import { Compute } from '../../types/utils.js';
+import { UseMutationReturnType } from '../../types/query.js';
+import { AuthMethod } from '@getpara/web-sdk';
+type UseInitiateLoginReturnType<TData = Set<AuthMethod>, TError = Error, TVariables = InitiateLoginArgs, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    initiateLogin: UseMutateFunction<TData, TError, TVariables, TContext>;
+    initiateLoginAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for initiating a user login
+ */
+export declare const useInitiateLogin: () => UseInitiateLoginReturnType<Set<AuthMethod>, Error, import("@getpara/user-management-client").PrimaryAuth, unknown>;
+export {};

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

@@ -0,0 +1,12 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { Compute } from '../../types/utils.js';
+import { UseMutationReturnType } from '../../types/query.js';
+type UseKeepSessionAliveReturnType<TData = void, TError = Error, TVariables = void, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    keepSessionAlive: UseMutateFunction<TData, TError, TVariables, TContext>;
+    keepSessionAliveAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for keeping a session alive
+ */
+export declare const useKeepSessionAlive: () => UseKeepSessionAliveReturnType<void, Error, void, unknown>;
+export {};

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

@@ -0,0 +1,13 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { LogoutArgs } from '../../actions/logout.js';
+import { Compute } from '../../types/utils.js';
+import { UseMutationReturnType } from '../../types/query.js';
+type UseLogoutReturnType<TData = void, TError = Error, TVariables = LogoutArgs | undefined, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    logout: UseMutateFunction<TData, TError, TVariables, TContext>;
+    logoutAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for logging out a user
+ */
+export declare const useLogout: () => UseLogoutReturnType<void, Error, LogoutArgs | undefined, unknown>;
+export {};

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

@@ -0,0 +1,15 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { SignMessageArgs } from '../../actions/signMessage.js';
+import { Compute } from '../../types/utils.js';
+import { UseMutationReturnType } from '../../types/query.js';
+import { FullSignatureRes } from '@getpara/web-sdk';
+type SignMessageMutationArgs = Omit<SignMessageArgs, 'walletId'> & Partial<Pick<SignMessageArgs, 'walletId'>>;
+type UseSignMessageReturnType<TData = FullSignatureRes, TError = Error, TVariables = SignMessageMutationArgs, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    signMessage: UseMutateFunction<TData, TError, TVariables, TContext>;
+    signMessageAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for signing a message
+ */
+export declare const useSignMessage: () => UseSignMessageReturnType<FullSignatureRes, Error, SignMessageMutationArgs, unknown>;
+export {};

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

@@ -0,0 +1,15 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { SignTransactionArgs } from '../../actions/signTransaction.js';
+import { Compute } from '../../types/utils.js';
+import { UseMutationReturnType } from '../../types/query.js';
+import { FullSignatureRes } from '@getpara/web-sdk';
+type SignTransactionMutationArgs = Omit<SignTransactionArgs, 'walletId'> & Partial<Pick<SignTransactionArgs, 'walletId'>>;
+type UseSignTransactionReturnType<TData = FullSignatureRes, TError = Error, TVariables = SignTransactionMutationArgs, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    signTransaction: UseMutateFunction<TData, TError, TVariables, TContext>;
+    signTransactionAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for signing a transaction
+ */
+export declare const useSignTransaction: () => UseSignTransactionReturnType<FullSignatureRes, Error, SignTransactionMutationArgs, unknown>;
+export {};

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

@@ -0,0 +1,13 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { waitForAccountCreationArgs } from '../../actions/waitForAccountCreation.js';
+import { UseMutationReturnType } from '../../types/query.js';
+import { Compute } from '../../types/utils.js';
+type UseWaitForAccountCreationReturnType<TData = boolean, TError = Error, TVariables = waitForAccountCreationArgs, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    waitForAccountCreation: UseMutateFunction<TData, TError, TVariables, TContext>;
+    waitForAccountCreationAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for waiting for account creation
+ */
+export declare const useWaitForAccountCreation: () => UseWaitForAccountCreationReturnType<boolean, Error, waitForAccountCreationArgs, unknown>;
+export {};

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

@@ -0,0 +1,14 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { WaitForLoginAndSetupArgs } from '../../actions/waitForLoginAndSetup.js';
+import { Compute } from '../../types/utils.js';
+import { UseMutationReturnType } from '../../types/query.js';
+import { LoginResponse } from '@getpara/web-sdk';
+type UseWaitForLoginAndSetupReturnType<TData = LoginResponse, TError = Error, TVariables = WaitForLoginAndSetupArgs, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    waitForLoginAndSetup: UseMutateFunction<TData, TError, TVariables, TContext>;
+    waitForLoginAndSetupAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for waiting for user login and account setup
+ */
+export declare const useWaitForLoginAndSetup: () => UseWaitForLoginAndSetupReturnType<LoginResponse, Error, WaitForLoginAndSetupArgs, unknown>;
+export {};

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

@@ -0,0 +1,13 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { UseMutationReturnType } from '../../types/query.js';
+import { Compute } from '../../types/utils.js';
+import { AccountSetupResponse } from '@getpara/web-sdk';
+type UseWaitForPasskeyAndCreateWalletReturnType<TData = AccountSetupResponse, TError = Error, TVariables = void, TContext = unknown> = Compute<UseMutationReturnType<TData, TError, TVariables, TContext> & {
+    waitForPasskeyAndCreateWallet: UseMutateFunction<TData, TError, TVariables, TContext>;
+    waitForPasskeyAndCreateWalletAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+}>;
+/**
+ * Hook for waiting for session setup and wallet creation
+ */
+export declare const useWaitForPasskeyAndCreateWallet: () => UseWaitForPasskeyAndCreateWalletReturnType<AccountSetupResponse, Error, void, unknown>;
+export {};

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

@@ -2,4 +2,10 @@ export declare const ACCOUNT_BASE_KEY = "PARA_ACCOUNT";
 /**
  * Hook for retrieving a user account
  */
-export declare const useAccount: () => import("@tanstack/react-query").UseQueryResult<import("../../actions/getAccount.js").Account, Error>;
+export declare const useAccount: () => import("@tanstack/react-query").UseQueryResult<{
+    isConnected: boolean;
+    email?: string;
+    phone?: string;
+    wallets?: Pick<import("@getpara/core-sdk").Wallet, "id" | "type" | "name" | "address" | "isExternal">[];
+    userId?: string;
+}, Error>;

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

@@ -1,12 +1,12 @@
 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 { ParaModalProps } from '../../modal/types/modalProps.js';
 import { TelegramAuthResponse, VerifiedAuth, VerifyExternalWalletParams } from '@getpara/user-management-client';
 type Value = {
     signUpOrLogIn: [(_: VerifiedAuth) => void, boolean];
     verifyNewAccount: [(_: string) => void, boolean, Error | null];
-    verifyOAuth: (_: CoreMethodParams<'verifyOAuth'>['method']) => void;
+    verifyOAuth: (_: CoreMethodParams<'verifyOAuthV2'>['method']) => void;
     verifyFarcaster: () => void;
     verifyTelegram: (_: TelegramAuthResponse) => void;
     verifyExternalWallet: (_: VerifyExternalWalletParams) => void;