@getpara/react-sdk 0.1.0 → 0.2.1

package/dist/provider/actions/waitForPasskeyAndCreateWallet.js

@@ -0,0 +1,24 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export const waitForPasskeyAndCreateWallet = (para) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!para) {
+        throw new Error('no para instance');
+    }
+    try {
+        const resp = yield para.waitForPasskeyAndCreateWallet();
+        if (!resp) {
+            throw new Error('error during waitForAccountCreation');
+        }
+        return resp;
+    }
+    catch (e) {
+        throw new Error(e);
+    }
+});

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

@@ -0,0 +1,3 @@
+export * from './utils/index.js';
+export * from './queries/index.js';
+export * from './mutations/index.js';

package/dist/provider/hooks/index.js

@@ -0,0 +1,3 @@
+export * from './utils/index.js';
+export * from './queries/index.js';
+export * from './mutations/index.js';

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

@@ -0,0 +1,10 @@
+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 { useLogout } from './useLogout.js';
+export { useKeepSessionAlive } from './useKeepSessionAlive.js';
+export { useSignMessage } from './useSignMessage.js';
+export { useSignTransaction } from './useSignTransaction.js';

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

@@ -0,0 +1,10 @@
+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 { useLogout } from './useLogout.js';
+export { useKeepSessionAlive } from './useKeepSessionAlive.js';
+export { useSignMessage } from './useSignMessage.js';
+export { useSignTransaction } from './useSignTransaction.js';

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/useCheckIfUserExists.js

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation } from '@tanstack/react-query';
+import { useClient } from '../index.js';
+import { checkIfUserExists } from '../../actions/checkIfUserExists.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for checking is a user exists
+ */
+export const useCheckIfUserExists = () => {
+    const client = useClient();
+    const mutation = useMutation({
+        mutationFn: (args) => __awaiter(void 0, void 0, void 0, function* () { return yield checkIfUserExists(client, args); }),
+    });
+    return renameMutations(mutation, 'checkIfUserExists');
+};

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/useCreateUser.js

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation } from '@tanstack/react-query';
+import { useClient } from '../index.js';
+import { createUser } from '../../actions/createUser.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for creating a new user
+ */
+export const useCreateUser = () => {
+    const client = useClient();
+    const mutation = useMutation({
+        mutationFn: (args) => __awaiter(void 0, void 0, void 0, function* () { return yield createUser(client, args); }),
+    });
+    return renameMutations(mutation, 'createUser');
+};

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, InitiateLoginArgs, unknown>;
+export {};

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

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation } from '@tanstack/react-query';
+import { useClient } from '../index.js';
+import { initiateLogin } from '../../actions/initiateLogin.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for initiating a user login
+ */
+export const useInitiateLogin = () => {
+    const client = useClient();
+    const mutation = useMutation({
+        mutationFn: (args) => __awaiter(void 0, void 0, void 0, function* () { return yield initiateLogin(client, args); }),
+    });
+    return renameMutations(mutation, 'initiateLogin');
+};

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/useKeepSessionAlive.js

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation } from '@tanstack/react-query';
+import { useClient } from '../index.js';
+import { keepSessionAlive } from '../../actions/keepSessionAlive.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for keeping a session alive
+ */
+export const useKeepSessionAlive = () => {
+    const client = useClient();
+    const mutation = useMutation({
+        mutationFn: () => __awaiter(void 0, void 0, void 0, function* () { return yield keepSessionAlive(client); }),
+    });
+    return renameMutations(mutation, 'keepSessionAlive');
+};

package/dist/provider/hooks/mutations/useLogout.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 UseLogoutReturnType<TData = void, TError = Error, TVariables = void, 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, void, unknown>;
+export {};

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

@@ -0,0 +1,33 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useClient } from '../index.js';
+import { logout } from '../../actions/logout.js';
+import { useStore } from '../../stores/useStore.js';
+import { ACCOUNT_BASE_KEY } from '../queries/useAccount.js';
+import { WALLET_BASE_KEY } from '../queries/useWallet.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for logging out a user
+ */
+export const useLogout = () => {
+    const client = useClient();
+    const queryClient = useQueryClient();
+    const clearSelectedWallet = useStore(state => state.clearSelectedWallet);
+    const mutation = useMutation({
+        mutationFn: () => __awaiter(void 0, void 0, void 0, function* () { return yield logout(client); }),
+        onSettled: () => __awaiter(void 0, void 0, void 0, function* () {
+            yield queryClient.invalidateQueries({ queryKey: [ACCOUNT_BASE_KEY], exact: false });
+            yield queryClient.invalidateQueries({ queryKey: [WALLET_BASE_KEY], exact: false });
+            clearSelectedWallet();
+        }),
+    });
+    return renameMutations(mutation, 'logout');
+};

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/useSignMessage.js

@@ -0,0 +1,33 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation } from '@tanstack/react-query';
+import { useClient, useWallet } from '../index.js';
+import { signMessage } from '../../actions/signMessage.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for signing a message
+ */
+export const useSignMessage = () => {
+    const client = useClient();
+    const { data: wallet } = useWallet();
+    const mutation = useMutation({
+        mutationFn: (args) => __awaiter(void 0, void 0, void 0, function* () {
+            let walletId = args === null || args === void 0 ? void 0 : args.walletId;
+            if (!walletId) {
+                walletId = wallet === null || wallet === void 0 ? void 0 : wallet.id;
+            }
+            if (!walletId) {
+                throw Error('no wallet id found');
+            }
+            return yield signMessage(client, Object.assign(Object.assign({}, args), { walletId }));
+        }),
+    });
+    return renameMutations(mutation, 'signMessage');
+};

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

@@ -0,0 +1,14 @@
+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 UseSignTransactionReturnType<TData = FullSignatureRes, TError = Error, TVariables = SignTransactionArgs, 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, SignTransactionArgs, unknown>;
+export {};

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

@@ -0,0 +1,33 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation } from '@tanstack/react-query';
+import { useClient, useWallet } from '../index.js';
+import { signTransaction } from '../../actions/signTransaction.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for signing a transaction
+ */
+export const useSignTransaction = () => {
+    const client = useClient();
+    const { data: wallet } = useWallet();
+    const mutation = useMutation({
+        mutationFn: (args) => __awaiter(void 0, void 0, void 0, function* () {
+            let walletId = args === null || args === void 0 ? void 0 : args.walletId;
+            if (!walletId) {
+                walletId = wallet === null || wallet === void 0 ? void 0 : wallet.id;
+            }
+            if (!walletId) {
+                throw Error('no wallet id found');
+            }
+            return yield signTransaction(client, Object.assign(Object.assign({}, args), { walletId }));
+        }),
+    });
+    return renameMutations(mutation, 'signTransaction');
+};

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

@@ -0,0 +1,12 @@
+import { UseMutateAsyncFunction, UseMutateFunction } from '@tanstack/react-query';
+import { UseMutationReturnType } from '../../types/query.js';
+import { Compute } from '../../types/utils.js';
+type UseWaitForAccountCreationReturnType<TData = boolean, TError = Error, TVariables = void, 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, void, unknown>;
+export {};

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

@@ -0,0 +1,30 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useClient } from '../index.js';
+import { waitForAccountCreation } from '../../actions/waitForAccountCreation.js';
+import { ACCOUNT_BASE_KEY } from '../queries/useAccount.js';
+import { WALLET_BASE_KEY } from '../queries/useWallet.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for waiting for account creation
+ */
+export const useWaitForAccountCreation = () => {
+    const client = useClient();
+    const queryClient = useQueryClient();
+    const mutation = useMutation({
+        mutationFn: () => __awaiter(void 0, void 0, void 0, function* () { return yield waitForAccountCreation(client); }),
+        onSettled: () => __awaiter(void 0, void 0, void 0, function* () {
+            yield queryClient.invalidateQueries({ queryKey: [ACCOUNT_BASE_KEY], exact: false });
+            yield queryClient.invalidateQueries({ queryKey: [WALLET_BASE_KEY], exact: false });
+        }),
+    });
+    return renameMutations(mutation, 'waitForAccountCreation');
+};

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 { LoginResp } from '@getpara/web-sdk';
+type UseWaitForLoginAndSetupReturnType<TData = LoginResp, 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<LoginResp, Error, WaitForLoginAndSetupArgs, unknown>;
+export {};

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

@@ -0,0 +1,30 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useClient } from '../index.js';
+import { waitForLoginAndSetup } from '../../actions/waitForLoginAndSetup.js';
+import { ACCOUNT_BASE_KEY } from '../queries/useAccount.js';
+import { WALLET_BASE_KEY } from '../queries/useWallet.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for waiting for user login and account setup
+ */
+export const useWaitForLoginAndSetup = () => {
+    const client = useClient();
+    const queryClient = useQueryClient();
+    const mutation = useMutation({
+        mutationFn: (args) => __awaiter(void 0, void 0, void 0, function* () { return yield waitForLoginAndSetup(client, args); }),
+        onSettled: () => __awaiter(void 0, void 0, void 0, function* () {
+            yield queryClient.invalidateQueries({ queryKey: [ACCOUNT_BASE_KEY], exact: false });
+            yield queryClient.invalidateQueries({ queryKey: [WALLET_BASE_KEY], exact: false });
+        }),
+    });
+    return renameMutations(mutation, 'waitForLoginAndSetup');
+};

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 { AccountSetupResp } from '@getpara/web-sdk';
+type UseWaitForPasskeyAndCreateWalletReturnType<TData = AccountSetupResp, 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<AccountSetupResp, Error, void, unknown>;
+export {};

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

@@ -0,0 +1,30 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useClient } from '../index.js';
+import { waitForPasskeyAndCreateWallet } from '../../actions/waitForPasskeyAndCreateWallet.js';
+import { ACCOUNT_BASE_KEY } from '../queries/useAccount.js';
+import { WALLET_BASE_KEY } from '../queries/useWallet.js';
+import { renameMutations } from '../../utils/renameMutations.js';
+/**
+ * Hook for waiting for session setup and wallet creation
+ */
+export const useWaitForPasskeyAndCreateWallet = () => {
+    const client = useClient();
+    const queryClient = useQueryClient();
+    const mutation = useMutation({
+        mutationFn: () => __awaiter(void 0, void 0, void 0, function* () { return yield waitForPasskeyAndCreateWallet(client); }),
+        onSettled: () => __awaiter(void 0, void 0, void 0, function* () {
+            yield queryClient.invalidateQueries({ queryKey: [ACCOUNT_BASE_KEY], exact: false });
+            yield queryClient.invalidateQueries({ queryKey: [WALLET_BASE_KEY], exact: false });
+        }),
+    });
+    return renameMutations(mutation, 'waitForPasskeyAndCreateWallet');
+};

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

@@ -0,0 +1,2 @@
+export { useAccount } from './useAccount.js';
+export { useWallet } from './useWallet.js';

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

@@ -0,0 +1,2 @@
+export { useAccount } from './useAccount.js';
+export { useWallet } from './useWallet.js';

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

@@ -0,0 +1,10 @@
+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;
+    email: any;
+    phone: any;
+    wallets: any;
+}, Error>;

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

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useQuery } from '@tanstack/react-query';
+import { useClient } from '../index.js';
+import { getAccount } from '../../actions/getAccount.js';
+export const ACCOUNT_BASE_KEY = 'PARA_ACCOUNT';
+/**
+ * Hook for retrieving a user account
+ */
+export const useAccount = () => {
+    const client = useClient();
+    return useQuery({
+        queryKey: [ACCOUNT_BASE_KEY, client === null || client === void 0 ? void 0 : client.getUserId()],
+        queryFn: () => __awaiter(void 0, void 0, void 0, function* () { return yield getAccount(client); }),
+    });
+};

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

@@ -0,0 +1,5 @@
+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>;

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

@@ -0,0 +1,24 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useQuery } from '@tanstack/react-query';
+import { useClient, useWalletState } from '../index.js';
+import { getWallet } from '../../actions/getWallet.js';
+export const WALLET_BASE_KEY = 'PARA_WALLET';
+/**
+ * Hook for retrieving the selected wallet
+ */
+export const useWallet = () => {
+    const client = useClient();
+    const { selectedWallet } = useWalletState();
+    return useQuery({
+        queryKey: [WALLET_BASE_KEY, client === null || client === void 0 ? void 0 : client.getUserId(), selectedWallet.id, selectedWallet.type],
+        queryFn: () => __awaiter(void 0, void 0, void 0, function* () { return yield getWallet(client, selectedWallet); }),
+    });
+};

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

@@ -0,0 +1,3 @@
+export { useClient } from './useClient.js';
+export { useModal } from './useModal.js';
+export { useWalletState } from './useWalletState.js';

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

@@ -0,0 +1,3 @@
+export { useClient } from './useClient.js';
+export { useModal } from './useModal.js';
+export { useWalletState } from './useWalletState.js';

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

@@ -0,0 +1,3 @@
+export declare const useAutoSessionKeepAlive: ({ disabled }: {
+    disabled?: boolean;
+}) => void;