@getpara/react-sdk-lite 2.0.0-alpha.33

package/dist/provider/external/stubs/CosmosExternalWalletContextStub.js

@@ -0,0 +1,8 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { defaultCosmosExternalWallet } from "@getpara/react-common";
+import { createContext } from "react";
+const CosmosExternalWalletContext = createContext(defaultCosmosExternalWallet);
+export {
+  CosmosExternalWalletContext
+};

package/dist/provider/external/stubs/EvmExternalWalletContextStub.d.ts

@@ -0,0 +1,2 @@
+import { type EvmExternalWalletContextType } from '@getpara/evm-wallet-connectors';
+export declare const EvmExternalWalletContext: import("react").Context<EvmExternalWalletContextType>;

package/dist/provider/external/stubs/EvmExternalWalletContextStub.js

@@ -0,0 +1,8 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { createContext } from "react";
+import { defaultEvmExternalWallet } from "@getpara/react-common";
+const EvmExternalWalletContext = createContext(defaultEvmExternalWallet);
+export {
+  EvmExternalWalletContext
+};

package/dist/provider/external/stubs/SolanaExternalWalletContextStub.d.ts

@@ -0,0 +1,2 @@
+import { type SolanaExternalWalletContextType } from '@getpara/solana-wallet-connectors';
+export declare const SolanaExternalWalletContext: import("react").Context<SolanaExternalWalletContextType>;

package/dist/provider/external/stubs/SolanaExternalWalletContextStub.js

@@ -0,0 +1,8 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { createContext } from "react";
+import { defaultSolanaExternalWallet } from "@getpara/react-common";
+const SolanaExternalWalletContext = createContext(defaultSolanaExternalWallet);
+export {
+  SolanaExternalWalletContext
+};

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,4 @@
+"use client";
+export * from "./utils/index.js";
+export * from "./queries/index.js";
+export * from "./mutations/index.js";

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

@@ -0,0 +1,27 @@
+export declare const useSignUpOrLogIn: () => import("../../types/utils.js").CoreMethodMutationHook<"signUpOrLogIn">;
+export declare const useVerifyNewAccount: () => import("../../types/utils.js").CoreMethodMutationHook<"verifyNewAccount">;
+export declare const useWaitForLogin: () => import("../../types/utils.js").CoreMethodMutationHook<"waitForLogin">;
+export declare const useWaitForSignup: () => import("../../types/utils.js").CoreMethodMutationHook<"waitForSignup">;
+export declare const useWaitForWalletCreation: () => import("../../types/utils.js").CoreMethodMutationHook<"waitForWalletCreation">;
+export declare const useVerifyOAuth: () => import("../../types/utils.js").CoreMethodMutationHook<"verifyOAuth">;
+export declare const useVerifyFarcaster: () => import("../../types/utils.js").CoreMethodMutationHook<"verifyFarcaster">;
+export declare const useVerifyTelegram: () => import("../../types/utils.js").CoreMethodMutationHook<"verifyTelegram">;
+export declare const useLoginExternalWallet: () => import("../../types/utils.js").CoreMethodMutationHook<"loginExternalWallet">;
+export declare const useVerifyExternalWallet: () => import("../../types/utils.js").CoreMethodMutationHook<"verifyExternalWallet">;
+export declare const useSetup2fa: () => import("../../types/utils.js").CoreMethodMutationHook<"setup2fa">;
+export declare const useEnable2fa: () => import("../../types/utils.js").CoreMethodMutationHook<"enable2fa">;
+export declare const useVerify2fa: () => import("../../types/utils.js").CoreMethodMutationHook<"verify2fa">;
+export declare const useKeepSessionAlive: () => import("../../types/utils.js").CoreMethodMutationHook<"keepSessionAlive">;
+export declare const useLogout: () => import("../../types/utils.js").CoreMethodMutationHook<"logout">;
+export declare const useResendVerificationCode: () => import("../../types/utils.js").CoreMethodMutationHook<"resendVerificationCode">;
+export declare const useCreateWallet: () => import("../../types/utils.js").CoreMethodMutationHook<"createWallet">;
+export declare const useCreateWalletPerType: () => import("../../types/utils.js").CoreMethodMutationHook<"createWalletPerType">;
+export declare const useCreatePregenWallet: () => import("../../types/utils.js").CoreMethodMutationHook<"createPregenWallet">;
+export declare const useCreatePregenWalletPerType: () => import("../../types/utils.js").CoreMethodMutationHook<"createPregenWalletPerType">;
+export declare const useClaimPregenWallets: () => import("../../types/utils.js").CoreMethodMutationHook<"claimPregenWallets">;
+export declare const useHasPregenWallet: () => import("../../types/utils.js").CoreMethodMutationHook<"hasPregenWallet">;
+export declare const useUpdatePregenWalletIdentifier: () => import("../../types/utils.js").CoreMethodMutationHook<"updatePregenWalletIdentifier">;
+export declare const useCreateGuestWallets: () => import("../../types/utils.js").CoreMethodMutationHook<"createGuestWallets">;
+export declare const useSignMessage: () => import("../../types/utils.js").CoreMethodMutationHook<"signMessage">;
+export declare const useSignTransaction: () => import("../../types/utils.js").CoreMethodMutationHook<"signTransaction">;
+export declare const useIssueJwt: () => import("../../types/utils.js").CoreMethodMutationHook<"issueJwt">;

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

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

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

@@ -0,0 +1,3 @@
+export * from './core.js';
+export * from './useLinkAccount.js';
+export declare const useCreateGuestWalletsState: import("../../types/utils.js").CoreMethodMutationStateHook<"createGuestWallets">;

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

@@ -0,0 +1,9 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { generateStateHook } from "./utils.js";
+export * from "./core.js";
+export * from "./useLinkAccount.js";
+const useCreateGuestWalletsState = generateStateHook("createGuestWallets");
+export {
+  useCreateGuestWalletsState
+};

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

@@ -0,0 +1,9 @@
+export declare const useLinkAccount: () => {
+    linkAccount: (_: import("../../providers/AccountLinkProvider.js").ModalLinkAccountArgs) => Promise<void>;
+    error: string | null;
+    status: import("@tanstack/query-core").MutationStatus;
+    isPending: boolean;
+    isError: boolean;
+    isIdle: boolean;
+    isSuccess: boolean;
+};

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

@@ -0,0 +1,18 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useAccountLinking } from "../../providers/AccountLinkProvider.js";
+const useLinkAccount = () => {
+  const { linkAccount, linkAccountError, linkAccountStatus } = useAccountLinking();
+  return {
+    linkAccount,
+    error: linkAccountError,
+    status: linkAccountStatus,
+    isPending: linkAccountStatus === "pending",
+    isError: linkAccountStatus === "error",
+    isIdle: linkAccountStatus === "idle",
+    isSuccess: linkAccountStatus === "success"
+  };
+};
+export {
+  useLinkAccount
+};

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

@@ -0,0 +1,12 @@
+import { CoreMethodName, CoreMethodParams, CoreMethods, InternalAction, InternalMethodName, InternalMethodParams, InternalMethods } from '@getpara/web-sdk';
+import { CoreMethodMutationHook, CoreMethodMutationStateHook, InternalMethodMutationHook } from '../../types/utils.js';
+import { CoreAction } from '../../actions/utils.js';
+export declare function generateCoreMutation<const method extends CoreMethodName & keyof CoreMethods>(method: method, action: CoreAction<method>, { delay, defaultParams, }?: {
+    delay?: number;
+    defaultParams?: CoreMethodParams<method>;
+}): () => CoreMethodMutationHook<method>;
+export declare function generateInternalMutation<const method extends InternalMethodName & keyof InternalMethods>(method: method, action: InternalAction<method>, { delay, defaultParams, }?: {
+    delay?: number;
+    defaultParams?: InternalMethodParams<method>;
+}): () => InternalMethodMutationHook<method>;
+export declare function generateStateHook<const method extends CoreMethodName & keyof CoreMethods>(method: method): CoreMethodMutationStateHook<method>;

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

@@ -0,0 +1,90 @@
+"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";
+import { useInternalClient } from "../utils/useInternalClient.js";
+function generateCoreMutation(method, action, {
+  delay,
+  defaultParams
+} = {}) {
+  return () => {
+    const para = useClient();
+    const mutation = useMutation({
+      mutationKey: [method],
+      mutationFn: (args) => __async(this, null, function* () {
+        if (typeof delay === "number") yield new Promise((resolve) => setTimeout(resolve, delay));
+        try {
+          const result = yield action(para, args != null ? args : defaultParams);
+          return result;
+        } catch (error) {
+          throw error;
+        }
+      })
+    });
+    return renameCoreMutations(mutation, method);
+  };
+}
+function generateInternalMutation(method, action, {
+  delay,
+  defaultParams
+} = {}) {
+  return () => {
+    const para = useInternalClient();
+    const mutation = useMutation({
+      mutationKey: [method],
+      mutationFn: (args) => __async(this, null, function* () {
+        if (typeof delay === "number") yield new Promise((resolve) => setTimeout(resolve, delay));
+        try {
+          const result = yield action(para, args != null ? args : defaultParams);
+          return result;
+        } catch (error) {
+          throw error;
+        }
+      })
+    });
+    return mutation;
+  };
+}
+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 {
+  generateCoreMutation,
+  generateInternalMutation,
+  generateStateHook
+};

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

@@ -0,0 +1,4 @@
+export declare const useLinkedAccounts: (params?: {
+    withMetadata?: boolean;
+} | undefined) => import("../../types/utils.js").CoreMethodQueryHook<"getLinkedAccounts">;
+export declare const useAccountLinkInProgress: (params?: undefined) => import("../../types/utils.js").CoreMethodQueryHook<"accountLinkInProgress">;

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

@@ -0,0 +1,16 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import * as actions from "../../actions/index.js";
+import { generateCoreQueryHook } from "./utils.js";
+const useLinkedAccounts = generateCoreQueryHook("getLinkedAccounts", actions.getLinkedAccounts, {
+  defaultParams: { withMetadata: false }
+});
+const useAccountLinkInProgress = generateCoreQueryHook(
+  "accountLinkInProgress",
+  actions.accountLinkInProgress,
+  { isGetter: true }
+);
+export {
+  useAccountLinkInProgress,
+  useLinkedAccounts
+};

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

@@ -0,0 +1,5 @@
+export { useAccount } from './useAccount.js';
+export { useParaStatus } from './useParaStatus.js';
+export { useWallet } from './useWallet.js';
+export { useWalletBalance } from './useWalletBalance.js';
+export * from './core.js';

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

@@ -0,0 +1,13 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useAccount } from "./useAccount.js";
+import { useParaStatus } from "./useParaStatus.js";
+import { useWallet } from "./useWallet.js";
+import { useWalletBalance } from "./useWalletBalance.js";
+export * from "./core.js";
+export {
+  useAccount,
+  useParaStatus,
+  useWallet,
+  useWalletBalance
+};

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

@@ -0,0 +1,90 @@
+import { useContext } from 'react';
+import { Account } from '../../actions/getEmbeddedAccount.js';
+import type { CosmosExternalWalletContextType, UseAccountParameters as UseCosmosAccountParameters } from '@getpara/cosmos-wallet-connectors';
+import type { EvmExternalWalletContextType } from '@getpara/evm-wallet-connectors';
+import type { Adapter } from '@getpara/solana-wallet-connectors';
+export declare const ACCOUNT_BASE_KEY = "PARA_ACCOUNT";
+type EVMAccountType = ReturnType<ReturnType<typeof useContext<EvmExternalWalletContextType>>['useAccount']>;
+type CosmosAccountType = Omit<ReturnType<ReturnType<typeof useContext<CosmosExternalWalletContextType>>['useAccount']>, 'reconnect'>;
+type SolanaAccountType = Pick<Adapter, 'publicKey' | 'name' | 'icon' | 'readyState' | 'supportedTransactionVersions' | 'url'> & {
+    isConnected?: boolean;
+    isConnecting?: boolean;
+};
+type ConnectionType = 'embedded' | 'external' | 'both' | 'none';
+type ExternalNetwork = 'evm' | 'cosmos' | 'solana';
+/**
+ * The return type for the useAccount hook.
+ *
+ * @property isConnected - Indicates whether there is a wallet connected (either embedded, external or both).
+ * @property isLoading - Indicates whether the account is currently loading.
+ * @property connectionType - The type of connection for the account:
+ * @property embedded - The embedded account object.
+ * @property external - An object containing connected external wallet account data:
+ *   - `evm`: The connected EVM wallet account (if any).
+ *   - `cosmos`: The connected Cosmos wallet account (if any), with the `reconnect` property omitted.
+ *   - `solana`: The connected Solana wallet adapter, with only allowed properties included.
+ */
+export type UseAccountReturn = {
+    /**
+     *  Indicates whether there is a wallet connected (either embedded, external or both).
+     */
+    isConnected: boolean;
+    /**
+     *  Indicates whether the account is currently loading.
+     */
+    isLoading: boolean;
+    /**
+     * The type of connection for the account.
+     * - 'embedded': Only the embedded account is connected.
+     * - 'external': Only an external wallet is connected.
+     * - 'both': Both embedded and external wallets are connected.
+     * - 'none': No wallets are connected.
+     */
+    connectionType: ConnectionType;
+    /**
+     * The embedded account object. Use this instead of the deprecated top-level properties.
+     */
+    embedded: Omit<Account, 'isReady' | 'isFarcasterMiniApp' | 'isConnected' | 'isGuestMode'> & {
+        isConnected: boolean;
+        isGuestMode?: boolean;
+    };
+    /**
+     * Connected external wallet account data.
+     */
+    external: {
+        /**
+         * The list of connected external networks, which can include 'evm', 'cosmos', and 'solana'.
+         */
+        connectedNetworks: ExternalNetwork[];
+        /**
+         * The connected EVM wallet (if any), with only allowed properties included.
+         */
+        evm: EVMAccountType;
+        /**
+         * The connected Cosmos wallet (if any), with only allowed properties included.
+         */
+        cosmos: CosmosAccountType;
+        /**
+         * The connected Solana wallet (if any), with only allowed properties included.
+         */
+        solana: SolanaAccountType;
+    };
+};
+export type UseAccountParameters = {
+    cosmos?: UseCosmosAccountParameters;
+};
+/**
+ * React Query hook for retrieving the current embedded account and connected external wallets.
+ *
+ * @returns {UseAccountReturn}
+ *   The account data object, or undefined while loading.
+ *
+ * The returned object contains:
+ * - `isConnected`: Indicates whether there is a wallet connected (either embedded, external or both).
+ * - `isLoading`: Indicates whether the account is currently loading.
+ * - `connectionType`: The type of connection for the account:
+ * - `embedded`: The embedded account object.
+ * - `external`: Connected external wallet data (EVM, Cosmos, Solana).
+ */
+export declare const useAccount: ({ cosmos }?: UseAccountParameters) => UseAccountReturn;
+export {};

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

@@ -0,0 +1,141 @@
+"use client";
+import {
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useInternalClient } from "../utils/useInternalClient.js";
+import { useIsFullyLoggedIn } from "./useIsFullyLoggedIn.js";
+import { useStore } from "../../stores/useStore.js";
+import { useContext } from "react";
+import { getEmbeddedAccount } from "../../actions/getEmbeddedAccount.js";
+const ACCOUNT_BASE_KEY = "PARA_ACCOUNT";
+function pickSolanaAdapter(adapter) {
+  if (!adapter) return { isConnected: false };
+  const { connected, connecting, publicKey, name, icon, readyState, supportedTransactionVersions, url } = adapter;
+  return {
+    isConnected: connected,
+    isConnecting: connecting,
+    publicKey,
+    name,
+    icon,
+    readyState,
+    supportedTransactionVersions,
+    url
+  };
+}
+function pickCosmosAccount(account) {
+  if (!account) return { isConnected: false };
+  const _a = account, { reconnect: _ } = _a, rest = __objRest(_a, ["reconnect"]);
+  return rest;
+}
+const useAccount = ({ cosmos } = {}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const client = useInternalClient();
+  const { data: isFullyLoggedIn, isSuccess } = useIsFullyLoggedIn();
+  const evmContext = useStore((state) => state.evmContext);
+  const { useAccount: useEvmAccount } = useContext(evmContext);
+  const evmAccount = useEvmAccount();
+  const evmQueryKeys = [evmAccount == null ? void 0 : evmAccount.status, evmAccount == null ? void 0 : evmAccount.addresses, evmAccount == null ? void 0 : evmAccount.chainId];
+  const cosmosContext = useStore((state) => state.cosmosContext);
+  const { useAccount: useCosmosAccount } = useContext(cosmosContext);
+  const cosmosAccount = useCosmosAccount(cosmos);
+  const cosmosQueryKeys = [cosmosAccount == null ? void 0 : cosmosAccount.status, cosmosAccount == null ? void 0 : cosmosAccount.data];
+  const solanaContext = useStore((state) => state.solanaContext);
+  const { useWallet: useSolanaWallet } = useContext(solanaContext);
+  const solanaWallet = useSolanaWallet();
+  const solanaQueryKeys = [
+    (_b = (_a = solanaWallet == null ? void 0 : solanaWallet.wallet) == null ? void 0 : _a.adapter) == null ? void 0 : _b.connected,
+    (_d = (_c = solanaWallet == null ? void 0 : solanaWallet.wallet) == null ? void 0 : _c.adapter) == null ? void 0 : _d.connecting,
+    (_f = (_e = solanaWallet == null ? void 0 : solanaWallet.wallet) == null ? void 0 : _e.adapter) == null ? void 0 : _f.publicKey
+  ];
+  const solanaAdapter = (_g = solanaWallet == null ? void 0 : solanaWallet.wallet) == null ? void 0 : _g.adapter;
+  const { data, isLoading } = useQuery({
+    enabled: isSuccess && !!client,
+    queryKey: [
+      ACCOUNT_BASE_KEY,
+      isFullyLoggedIn != null ? isFullyLoggedIn : null,
+      (_h = client == null ? void 0 : client.userId) != null ? _h : null,
+      evmQueryKeys,
+      cosmosQueryKeys,
+      solanaQueryKeys
+    ],
+    queryFn: () => {
+      const paraAccount = getEmbeddedAccount(client, isFullyLoggedIn);
+      let connectionType = "none";
+      if (paraAccount.isConnected) {
+        connectionType = "embedded";
+        if (paraAccount.wallets.some((w) => w.isExternal)) {
+          connectionType = "both";
+        }
+        if (paraAccount.wallets.every((w) => w.isExternal) && ((evmAccount == null ? void 0 : evmAccount.isConnected) || (cosmosAccount == null ? void 0 : cosmosAccount.isConnected) || (solanaAdapter == null ? void 0 : solanaAdapter.connected))) {
+          connectionType = "external";
+        }
+      }
+      const isEmbeddedConnected = paraAccount.isConnected && (!!paraAccount.userId || paraAccount.isGuestMode);
+      const connectedNetworks = [];
+      if (evmAccount == null ? void 0 : evmAccount.isConnected) {
+        connectedNetworks.push("evm");
+      }
+      if (cosmosAccount == null ? void 0 : cosmosAccount.isConnected) {
+        connectedNetworks.push("cosmos");
+      }
+      if (solanaAdapter == null ? void 0 : solanaAdapter.connected) {
+        connectedNetworks.push("solana");
+      }
+      return {
+        isConnected: paraAccount.isConnected,
+        connectionType,
+        embedded: __spreadProps(__spreadValues({}, paraAccount), { isConnected: isEmbeddedConnected }),
+        external: {
+          connectedNetworks,
+          evm: evmAccount != null ? evmAccount : {
+            address: void 0,
+            addresses: void 0,
+            chain: void 0,
+            chainId: void 0,
+            connector: void 0,
+            isConnected: false,
+            isReconnecting: false,
+            isConnecting: false,
+            isDisconnected: true,
+            status: "disconnected"
+          },
+          cosmos: pickCosmosAccount(cosmosAccount),
+          solana: pickSolanaAdapter(solanaAdapter)
+        }
+      };
+    }
+  });
+  const defaultResp = {
+    isConnected: false,
+    connectionType: "none",
+    isLoading,
+    embedded: {
+      isConnected: false
+    },
+    external: {
+      connectedNetworks: [],
+      evm: {
+        address: void 0,
+        addresses: void 0,
+        chain: void 0,
+        chainId: void 0,
+        connector: void 0,
+        isConnected: false,
+        isReconnecting: false,
+        isConnecting: false,
+        isDisconnected: true,
+        status: "disconnected"
+      },
+      cosmos: { isConnected: false },
+      solana: { isConnected: false }
+    }
+  };
+  return __spreadProps(__spreadValues({}, data != null ? data : defaultResp), { isLoading });
+};
+export {
+  ACCOUNT_BASE_KEY,
+  useAccount
+};

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

@@ -0,0 +1,5 @@
+export declare const IS_FULLY_LOGGED_IN_BASE_KEY = "PARA_FULLY_LOGGED_IN";
+/**
+ * Hook for returning whether the user is fully logged in with Para
+ */
+export declare const useIsFullyLoggedIn: () => import("@tanstack/react-query").UseQueryResult<boolean, Error>;

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

@@ -0,0 +1,24 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useInternalClient } from "../utils/useInternalClient.js";
+const IS_FULLY_LOGGED_IN_BASE_KEY = "PARA_FULLY_LOGGED_IN";
+const useIsFullyLoggedIn = () => {
+  var _a;
+  const client = useInternalClient();
+  return useQuery({
+    enabled: !!(client == null ? void 0 : client.isReady),
+    staleTime: 5e3,
+    queryKey: [IS_FULLY_LOGGED_IN_BASE_KEY, (_a = client == null ? void 0 : client.userId) != null ? _a : null],
+    queryFn: () => __async(void 0, null, function* () {
+      var _a2;
+      return (_a2 = yield client == null ? void 0 : client.isFullyLoggedIn()) != null ? _a2 : false;
+    })
+  });
+};
+export {
+  IS_FULLY_LOGGED_IN_BASE_KEY,
+  useIsFullyLoggedIn
+};

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

@@ -0,0 +1,22 @@
+export declare const IS_FULLY_LOGGED_IN_BASE_KEY = "PARA_FULLY_LOGGED_IN";
+export type ParaStatus = {
+    /**
+     * Indicates whether the client's first-time setup is complete.
+     */
+    isReady: boolean;
+    /**
+     * Indicates whether the current application is a Farcaster Mini App.
+     */
+    isFarcasterMiniApp: boolean;
+};
+/**
+ * Hook for retrieving the initial setup status of the Para client.
+ *
+ * @example
+ * const status = useParaStatus();
+ * if (status.isReady) {
+ *   const isFarcasterMiniApp = status.isFarcasterMiniApp;
+ *   // ...
+ * }
+ */
+export declare const useParaStatus: () => ParaStatus;

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

@@ -0,0 +1,25 @@
+"use client";
+import "../../../chunk-MMUBH76A.js";
+import { useQuery } from "@tanstack/react-query";
+import { useInternalClient } from "../utils/useInternalClient.js";
+const IS_FULLY_LOGGED_IN_BASE_KEY = "PARA_FULLY_LOGGED_IN";
+const useParaStatus = () => {
+  var _a, _b;
+  const client = useInternalClient();
+  const { data } = useQuery({
+    enabled: !!client,
+    queryKey: ["useParaStatus", (_a = client == null ? void 0 : client.isReady) != null ? _a : null, (_b = client == null ? void 0 : client.isFarcasterMiniApp) != null ? _b : null],
+    queryFn: () => {
+      var _a2, _b2;
+      return {
+        isReady: (_a2 = client == null ? void 0 : client.isReady) != null ? _a2 : false,
+        isFarcasterMiniApp: (_b2 = client == null ? void 0 : client.isFarcasterMiniApp) != null ? _b2 : false
+      };
+    }
+  });
+  return data != null ? data : { isReady: false, isFarcasterMiniApp: false };
+};
+export {
+  IS_FULLY_LOGGED_IN_BASE_KEY,
+  useParaStatus
+};