@getpara/react-sdk 2.0.0-alpha.19 → 2.0.0-alpha.21

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

@@ -7,19 +7,49 @@ import {
 import { renameCoreMutations } from "../../utils/renameMutations.js";
 import { useClient } from "../utils/index.js";
 import { useMutation, useMutationState } from "@tanstack/react-query";
-function generateHook(method, action, defaultParams) {
+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* () {
-        const result = yield action(para, args != null ? args : defaultParams);
-        return result;
+        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({
@@ -54,6 +84,7 @@ function generateStateHook(method) {
   };
 }
 export {
-  generateHook,
+  generateCoreMutation,
+  generateInternalMutation,
   generateStateHook
 };

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

@@ -0,0 +1,2 @@
+export declare const useLinkedAccounts: () => import("../../types/utils.js").CoreMethodQueryHook<"getLinkedAccounts">;
+export declare const useAccountLinkInProgress: () => import("../../types/utils.js").CoreMethodQueryHook<"accountLinkInProgress">;

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

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

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

@@ -1,3 +1,4 @@
 export { useAccount } from './useAccount.js';
 export { useWallet } from './useWallet.js';
 export { useWalletBalance } from './useWalletBalance.js';
+export * from './core.js';

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

@@ -3,6 +3,7 @@ import "../../../chunk-MMUBH76A.js";
 import { useAccount } from "./useAccount.js";
 import { useWallet } from "./useWallet.js";
 import { useWalletBalance } from "./useWalletBalance.js";
+export * from "./core.js";
 export {
   useAccount,
   useWallet,

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

@@ -0,0 +1,4 @@
+import ParaWeb, { CoreMethodName, CoreMethods } from '@getpara/web-sdk';
+import { CoreMethodQueryHook } from '../../types/utils.js';
+import { CoreAction } from '../../actions/utils.js';
+export declare function generateCoreQueryHook<const method extends CoreMethodName & keyof CoreMethods>(method: method, action: CoreAction<method> & ((_: ParaWeb) => Promise<unknown>)): () => CoreMethodQueryHook<method>;

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

@@ -0,0 +1,24 @@
+"use client";
+import {
+  __async
+} from "../../../chunk-MMUBH76A.js";
+import { useClient } from "../utils/index.js";
+import { useQuery } from "@tanstack/react-query";
+function generateCoreQueryHook(method, action) {
+  return () => {
+    const para = useClient();
+    return useQuery({
+      queryKey: [method],
+      queryFn: () => __async(this, null, function* () {
+        if (!para) {
+          return null;
+        }
+        const result = yield action(para);
+        return result;
+      })
+    });
+  };
+}
+export {
+  generateCoreQueryHook
+};

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

@@ -1,8 +1,11 @@
+import { ModalStep } from '../../../modal/index.js';
 /**
  * Hook for controlling the Para modal
  */
 export declare const useModal: () => {
     isOpen: boolean;
-    openModal: () => void;
+    openModal: ({ step }?: {
+        step?: ModalStep;
+    }) => void;
     closeModal: () => void;
 };

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

@@ -1,13 +1,23 @@
 "use client";
 import "../../../chunk-MMUBH76A.js";
+import { useModalStore } from "../../../modal/stores/index.js";
 import { useStore } from "../../stores/useStore.js";
 const useModal = () => {
   const isOpen = useStore((state) => state.isOpen);
   const setIsOpen = useStore((state) => state.setIsOpen);
-  const openModal = () => {
-    setIsOpen(true);
+  const openedToStep = useStore((state) => state.openedToStep);
+  const setStep = useModalStore((state) => state.setStep);
+  const openModal = ({ step } = {}) => {
+    if (step) {
+      openedToStep.current = step;
+      setStep(step);
+    }
+    if (!isOpen) {
+      setIsOpen(true);
+    }
   };
   const closeModal = () => {
+    openedToStep.current = null;
     setIsOpen(false);
   };
   return { isOpen, openModal, closeModal };

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

@@ -0,0 +1,42 @@
+import { PropsWithChildren } from 'react';
+import { MutationStatus } from '@tanstack/react-query';
+import { AccountLinkError, AccountLinkInProgress as CoreAccountLinkInProgress, LinkedAccount, LinkedAccounts, SupportedAccountLinks, TelegramAuthResponse, TExternalWallet, TLinkedAccountType, Auth, InternalMethodParams } from '@getpara/web-sdk';
+type AccountLinkInProgress = Partial<CoreAccountLinkInProgress & {
+    pendingWalletType?: TExternalWallet;
+}>;
+export type ModalLinkAccountArgs = undefined | {
+    auth: Auth<'email' | 'phone'>;
+} | {
+    type: Exclude<TLinkedAccountType, 'EXTERNAL_WALLET'> | 'X';
+} | {
+    externalWallet: TExternalWallet;
+} | {
+    options: SupportedAccountLinks;
+};
+type Value = {
+    isEnabled: boolean;
+    accountLinkInProgress: AccountLinkInProgress | undefined;
+    accountLinkOptions: SupportedAccountLinks;
+    linkAccount: (_: ModalLinkAccountArgs) => Promise<void>;
+    isLinkAccountPending: boolean;
+    verifyEmailOrPhoneLink: (verificationCode: string) => void;
+    verifyOAuthLink: (method: InternalMethodParams<'verifyOAuthLink'>['method']) => void;
+    verifyFarcasterLink: () => void;
+    verifyTelegramLink: (telegramAuthResponse: TelegramAuthResponse) => void;
+    verifyLinkedAccount: (accountLinkInProgress: AccountLinkInProgress) => void;
+    linkAccountStatus: MutationStatus;
+    linkAccountError: string | null;
+    setLinkAccountError: (_: AccountLinkError | null) => void;
+    unlinkingAccount: LinkedAccount | undefined;
+    unlinkAccount: (linkedAccount: LinkedAccount) => void;
+    unlinkAccountConfirm: () => void;
+    isUnlinkAccountPending: boolean;
+    cancelLinkAccount: () => void;
+    onAccountLinked: (_: AccountLinkInProgress) => void;
+    onAccountLinkVerified: (_: LinkedAccounts) => void;
+    resetMutations: () => void;
+};
+export declare const AccountLinkContext: import("react").Context<Value>;
+export declare const AccountLinkProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export declare const useAccountLinking: () => Value;
+export {};

package/dist/provider/providers/AccountLinkProvider.js

@@ -0,0 +1,443 @@
+"use client";
+import {
+  __async
+} from "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
+import { useAccount, useAccountLinkInProgress, useModal } from "../index.js";
+import * as actions from "../actions/index.js";
+import { useQueryClient } from "@tanstack/react-query";
+import {
+  AccountLinkError,
+  LINKED_ACCOUNT_TYPES
+} from "@getpara/web-sdk";
+import { useModalStore } from "../../modal/stores/index.js";
+import { ModalStep, openPopup } from "../../modal/index.js";
+import { useGoBack } from "../../modal/hooks/useGoBack.js";
+import { useExternalWallets } from "./ExternalWalletProvider.js";
+import { useInternalClient } from "../hooks/utils/useInternalClient.js";
+import { generateInternalMutation } from "../hooks/mutations/utils.js";
+import { validateAuth } from "../../modal/utils/authInputHelpers.js";
+import { extractAuthInfo } from "@getpara/user-management-client";
+import { useStore } from "../stores/useStore.js";
+const AccountLinkContext = createContext({
+  isEnabled: false,
+  accountLinkInProgress: void 0,
+  accountLinkOptions: [...LINKED_ACCOUNT_TYPES],
+  linkAccount: () => Promise.resolve(),
+  isLinkAccountPending: false,
+  verifyEmailOrPhoneLink: () => {
+  },
+  verifyOAuthLink: () => {
+  },
+  verifyFarcasterLink: () => {
+  },
+  verifyTelegramLink: () => {
+  },
+  verifyLinkedAccount: () => {
+  },
+  unlinkingAccount: void 0,
+  linkAccountStatus: "idle",
+  linkAccountError: null,
+  setLinkAccountError: () => {
+  },
+  unlinkAccount: () => {
+  },
+  unlinkAccountConfirm: () => {
+  },
+  isUnlinkAccountPending: false,
+  cancelLinkAccount: () => {
+  },
+  onAccountLinked: () => {
+  },
+  onAccountLinkVerified: () => {
+  },
+  resetMutations: () => {
+  }
+  // externalWalletQrUri: undefined,
+});
+const useLinkAccount = generateInternalMutation("linkAccount", actions.linkAccount);
+const useUnlinkAccount = generateInternalMutation("unlinkAccount", actions.unlinkAccount);
+const useVerifyOAuthLink = generateInternalMutation("verifyOAuthLink", actions.verifyOAuthLink, { delay: 500 });
+const useVerifyEmailOrPhoneLink = generateInternalMutation("verifyEmailOrPhoneLink", actions.verifyEmailOrPhoneLink);
+const useVerifyFarcasterLink = generateInternalMutation("verifyFarcasterLink", actions.verifyFarcasterLink, {
+  delay: 500
+});
+const useVerifyTelegramLink = generateInternalMutation("verifyTelegramLink", actions.verifyTelegramLink);
+const useVerifyExternalWalletLink = generateInternalMutation("verifyExternalWalletLink", actions.verifyExternalWalletLink);
+const AccountLinkProvider = ({ children }) => {
+  const para = useInternalClient();
+  const queryClient = useQueryClient();
+  const { data: account } = useAccount();
+  const { data: coreAccountLinkInProgress } = useAccountLinkInProgress();
+  const {
+    wallet: connectedWallet,
+    wallets,
+    signMessage,
+    isSigningMessage,
+    requestInfo: externalWalletRequestInfo,
+    disconnectBase
+  } = useExternalWallets();
+  const { isOpen, openModal } = useModal();
+  const includeWalletVerification = useStore((state) => state.includeWalletVerification);
+  const setStep = useModalStore((state) => state.setStep);
+  const setFarcasterConnectUri = useModalStore((state) => state.setFarcasterConnectUri);
+  const refs = useModalStore((state) => state.refs);
+  const externalWalletError = useModalStore((state) => state.externalWalletError);
+  const accountLinkOptions = useModalStore((state) => state.accountLinkOptions) || [...LINKED_ACCOUNT_TYPES];
+  const setAccountLinkOptions = useModalStore((state) => state.setAccountLinkOptions);
+  const goBack = useGoBack();
+  const { mutateAsync: mutateLinkAccountAsync, isPending: isLinkAccountPending } = useLinkAccount();
+  const { mutate: mutateUnlinkAccount, isPending: isUnlinkAccountPending } = useUnlinkAccount();
+  const {
+    mutate: mutateVerifyEmailOrPhoneLink,
+    status: statusVerifyEmailOrPhoneLink,
+    reset: resetVerifyEmailOrPhoneLink
+  } = useVerifyEmailOrPhoneLink();
+  const { mutate: mutateVerifyOAuthLink, status: statusVerifyOAuthLink, reset: resetVerifyOAuthLink } = useVerifyOAuthLink();
+  const {
+    mutate: mutateVerifyFarcasterLink,
+    status: statusVerifyFarcasterLink,
+    reset: resetVerifyFarcasterLink
+  } = useVerifyFarcasterLink();
+  const {
+    mutateAsync: mutateVerifyTelegramLinkAsync,
+    status: statusVerifyTelegramLink,
+    reset: resetVerifyTelegramLink
+  } = useVerifyTelegramLink();
+  const {
+    mutateAsync: mutateAsyncVerifyExternalWalletLink,
+    status: statusVerifyExternalWalletLink,
+    reset: resetVerifyExternalWalletLink
+  } = useVerifyExternalWalletLink();
+  const isEnabled = !!(account == null ? void 0 : account.isConnected) && !(account == null ? void 0 : account.isGuestMode) && (!(account == null ? void 0 : account.externalWallet) || includeWalletVerification);
+  const [accountLinkInProgress, setAccountLinkInProgress] = useState(
+    coreAccountLinkInProgress
+  );
+  const [unlinkingAccount, setUnlinkingAccount] = useState(void 0);
+  const [linkAccountError, setLinkAccountError] = useState(null);
+  const [linkAccountStatus, setLinkAccountStatus] = useState("pending");
+  const linkAccount = (args) => __async(void 0, null, function* () {
+    if (!isEnabled) {
+      setLinkAccountError(AccountLinkError.NotAuthenticated);
+      throw new Error(AccountLinkError.NotAuthenticated);
+    }
+    setLinkAccountError(null);
+    switch (true) {
+      case !args:
+      case (args && "options" in args):
+        {
+          const options = (args == null ? void 0 : args.options) || (para == null ? void 0 : para.supportedAccountLinks) || [...LINKED_ACCOUNT_TYPES];
+          if (options.length < 2) {
+            throw new Error("Account linking options array must contain 2 or more items");
+          }
+          setAccountLinkOptions(options);
+          openModal({ step: ModalStep.ACCOUNT_PROFILE_LIST });
+        }
+        break;
+      case (args && "externalWallet" in args):
+        {
+          const providerId = args.externalWallet;
+          if (providerId === (connectedWallet == null ? void 0 : connectedWallet.internalId)) {
+            throw new Error(`Cannot link the currently connected external wallet: ${providerId}`);
+          }
+          setAccountLinkInProgress({ type: "EXTERNAL_WALLET", pendingWalletType: providerId });
+          const linkWallet = wallets.find((w) => w.internalId === providerId);
+          if (!linkWallet) {
+            throw new Error(`wallet not installed: ${providerId}`);
+          }
+          openModal({ step: ModalStep.ACCOUNT_PROFILE_ADD });
+          try {
+            const externalWallet = yield externalWalletRequestInfo(providerId);
+            const accountLinkInProgress2 = yield mutateLinkAccountAsync({ externalWallet });
+            yield onAccountLinked(accountLinkInProgress2);
+            const signatureVerificationMessage = accountLinkInProgress2.externalWallet.signatureVerificationMessage;
+            yield new Promise((resolve) => setTimeout(resolve, 100));
+            const {
+              signature: signedMessage,
+              cosmosPublicKeyHex,
+              cosmosSigner
+            } = yield signMessage({
+              message: signatureVerificationMessage,
+              externalWallet: accountLinkInProgress2.externalWallet
+            });
+            const updatedAccounts = yield mutateAsyncVerifyExternalWalletLink({
+              signedMessage,
+              cosmosPublicKeyHex,
+              cosmosSigner
+            });
+            yield onAccountLinkVerified(updatedAccounts);
+          } catch (e) {
+            console.error(e);
+            setLinkAccountError(`Error authenticating external wallet: ${e.message}`);
+          } finally {
+            if (linkWallet.type === "EVM" || linkWallet.type === "SOLANA") {
+              yield disconnectBase(providerId);
+            }
+          }
+        }
+        break;
+      default: {
+        switch (true) {
+          case "auth" in args:
+            {
+              validateAuth(args.auth);
+              const authInfo = extractAuthInfo(args.auth, { isRequired: true });
+              setAccountLinkInProgress({
+                type: authInfo.authType.toUpperCase(),
+                identifier: authInfo.identifier
+              });
+            }
+            break;
+          case "type" in args: {
+            if (args.type === "EMAIL" || args.type === "PHONE" || !isOpen) {
+              setAccountLinkInProgress({ type: args.type === "X" ? "TWITTER" : args.type });
+            }
+            break;
+          }
+        }
+        if (!isOpen) {
+          openModal({ step: ModalStep.ACCOUNT_PROFILE_ADD });
+        }
+        try {
+          const accountLinkInProgress2 = yield mutateLinkAccountAsync(args);
+          yield onAccountLinked(accountLinkInProgress2);
+        } catch (e) {
+          setLinkAccountError(e.message);
+        }
+      }
+    }
+  });
+  const onAccountLinked = (accountLinkInProgress2) => __async(void 0, null, function* () {
+    queryClient.setQueryData(["accountLinkInProgress"], accountLinkInProgress2 != null ? accountLinkInProgress2 : null);
+    setStep(ModalStep.ACCOUNT_PROFILE_ADD);
+    switch (accountLinkInProgress2.type) {
+      case "EMAIL":
+      case "PHONE":
+      case "TELEGRAM":
+      case "EXTERNAL_WALLET":
+        break;
+      case "FARCASTER":
+        verifyFarcasterLink();
+        break;
+      default:
+        verifyLinkedAccount(accountLinkInProgress2);
+    }
+  });
+  const verifyEmailOrPhoneLink = (verificationCode) => __async(void 0, null, function* () {
+    mutateVerifyEmailOrPhoneLink(
+      { verificationCode },
+      {
+        onSuccess: onAccountLinkVerified,
+        onError: onAccountLinkError
+      }
+    );
+  });
+  const verifyOAuthLink = (method) => __async(void 0, null, function* () {
+    mutateVerifyOAuthLink(
+      {
+        method,
+        isCanceled: () => {
+          var _a;
+          return !!((_a = refs.popupWindow.current) == null ? void 0 : _a.closed);
+        },
+        onOAuthUrl: (oAuthUrl) => {
+          refs.popupWindow.current = openPopup({
+            url: oAuthUrl,
+            target: `${method}AuthPopup`,
+            type: "OAUTH",
+            current: refs.popupWindow.current
+          });
+        }
+      },
+      {
+        onSuccess: onAccountLinkVerified,
+        onError: onAccountLinkError
+      }
+    );
+  });
+  const verifyFarcasterLink = () => __async(void 0, null, function* () {
+    mutateVerifyFarcasterLink(
+      {
+        isCanceled: () => refs.currentStep.current !== ModalStep.ACCOUNT_PROFILE_ADD,
+        onConnectUri: (connectUri) => {
+          setFarcasterConnectUri(connectUri);
+        }
+      },
+      {
+        onSuccess: onAccountLinkVerified,
+        onError: () => {
+          if (refs.currentStep.current === ModalStep.ACCOUNT_PROFILE_ADD) {
+            goBack();
+          }
+        }
+      }
+    );
+  });
+  const verifyTelegramLink = (telegramAuthResponse) => __async(void 0, null, function* () {
+    try {
+      const accounts = yield mutateVerifyTelegramLinkAsync({
+        telegramAuthResponse
+      });
+      onAccountLinkVerified(accounts);
+    } catch (e) {
+      onAccountLinkError(e);
+      throw e;
+    }
+  });
+  const verifyLinkedAccount = ({ type }) => {
+    switch (type) {
+      case "EMAIL":
+      case "PHONE":
+      case "TELEGRAM":
+      case "EXTERNAL_WALLET":
+        break;
+      case "FARCASTER":
+        verifyFarcasterLink();
+        break;
+      default:
+        verifyOAuthLink(type);
+        break;
+    }
+  };
+  const onAccountLinkVerified = (updatedAccounts) => {
+    queryClient.setQueryData(["getLinkedAccounts"], () => updatedAccounts);
+    setTimeout(() => {
+      setStep(ModalStep.ACCOUNT_PROFILE);
+    }, 2e3);
+  };
+  const onAccountLinkError = (e) => {
+    setLinkAccountError(e instanceof Error ? e.message : e);
+  };
+  const unlinkAccount = (linkedAccount) => {
+    setUnlinkingAccount(linkedAccount);
+    setStep(ModalStep.ACCOUNT_PROFILE_REMOVE);
+  };
+  const unlinkAccountConfirm = () => {
+    mutateUnlinkAccount(
+      {
+        linkedAccountId: unlinkingAccount.id
+      },
+      {
+        onSuccess: (updatedAccounts) => {
+          queryClient.setQueryData(["getLinkedAccounts"], () => updatedAccounts);
+          setUnlinkingAccount(void 0);
+          setStep(ModalStep.ACCOUNT_PROFILE);
+        }
+      }
+    );
+  };
+  const cancelLinkAccount = () => {
+    mutateUnlinkAccount(void 0);
+  };
+  const resetMutations = () => {
+    resetVerifyEmailOrPhoneLink();
+    resetVerifyFarcasterLink();
+    resetVerifyOAuthLink();
+    resetVerifyTelegramLink();
+    resetVerifyExternalWalletLink();
+  };
+  useEffect(() => {
+    setAccountLinkInProgress((prev) => {
+      return coreAccountLinkInProgress != null ? coreAccountLinkInProgress : prev;
+    });
+  }, [coreAccountLinkInProgress]);
+  useEffect(() => {
+    if (!isOpen) {
+      setLinkAccountError(null);
+      setAccountLinkInProgress(void 0);
+      setUnlinkingAccount(void 0);
+      resetMutations();
+    }
+  }, [isOpen]);
+  useEffect(() => {
+    setLinkAccountStatus(() => {
+      if (!isEnabled || !accountLinkInProgress) {
+        return "idle";
+      }
+      if ((accountLinkInProgress.type === "EMAIL" || accountLinkInProgress.type === "PHONE") && !accountLinkInProgress.identifier) {
+        return "idle";
+      }
+      if (linkAccountError) return "error";
+      switch (true) {
+        case accountLinkInProgress.type === "TELEGRAM":
+          return statusVerifyTelegramLink;
+        case accountLinkInProgress.type === "FARCASTER":
+          return statusVerifyFarcasterLink;
+        case accountLinkInProgress.type === "EMAIL":
+        case accountLinkInProgress.type === "PHONE":
+          return statusVerifyEmailOrPhoneLink;
+        case accountLinkInProgress.type === "EXTERNAL_WALLET":
+          if (isSigningMessage) return "pending";
+          return externalWalletError && externalWalletError.length > 0 ? "error" : statusVerifyExternalWalletLink === "idle" ? "pending" : statusVerifyExternalWalletLink;
+        default:
+          return statusVerifyOAuthLink;
+      }
+    });
+  }, [
+    linkAccountError,
+    isEnabled,
+    accountLinkInProgress,
+    statusVerifyEmailOrPhoneLink,
+    statusVerifyFarcasterLink,
+    statusVerifyOAuthLink,
+    statusVerifyTelegramLink,
+    statusVerifyExternalWalletLink,
+    externalWalletError,
+    isSigningMessage
+  ]);
+  const value = useMemo(
+    () => ({
+      isEnabled,
+      accountLinkInProgress,
+      accountLinkOptions,
+      linkAccount,
+      isLinkAccountPending,
+      verifyOAuthLink,
+      verifyFarcasterLink,
+      verifyTelegramLink,
+      verifyEmailOrPhoneLink,
+      verifyLinkedAccount,
+      linkAccountStatus,
+      linkAccountError,
+      setLinkAccountError,
+      unlinkingAccount,
+      unlinkAccount,
+      unlinkAccountConfirm,
+      isUnlinkAccountPending,
+      cancelLinkAccount,
+      onAccountLinked,
+      onAccountLinkVerified,
+      resetMutations
+    }),
+    [
+      isEnabled,
+      accountLinkInProgress,
+      accountLinkOptions,
+      linkAccount,
+      isLinkAccountPending,
+      verifyOAuthLink,
+      verifyFarcasterLink,
+      verifyTelegramLink,
+      verifyEmailOrPhoneLink,
+      verifyLinkedAccount,
+      linkAccountStatus,
+      linkAccountError,
+      setLinkAccountError,
+      unlinkAccount,
+      unlinkAccountConfirm,
+      isUnlinkAccountPending,
+      cancelLinkAccount,
+      onAccountLinked,
+      onAccountLinkVerified,
+      resetMutations
+    ]
+  );
+  return /* @__PURE__ */ jsx(AccountLinkContext.Provider, { value, children });
+};
+const useAccountLinking = () => useContext(AccountLinkContext);
+export {
+  AccountLinkContext,
+  AccountLinkProvider,
+  useAccountLinking
+};

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

@@ -3,15 +3,17 @@ import { PropsWithChildren } from 'react';
 import { AuthMethod, CoreMethodParams, AuthState, AuthStateSignup, AuthStateLogin } from '@getpara/web-sdk';
 import { ParaModalProps } from '../../modal/types/modalProps.js';
 import { TelegramAuthResponse, VerifiedAuth } from '@getpara/user-management-client';
+import { MutationStatus } from '@tanstack/react-query';
 type Value = {
     signUpOrLogIn: (_: VerifiedAuth) => void;
     isSignUpOrLogInPending: boolean;
     verifyNewAccount: (_: string) => void;
-    isVerifyNewAccountPending: boolean;
+    verifyNewAccountStatus: MutationStatus;
     verifyNewAccountError: Error | null;
     verifyOAuth: (_: CoreMethodParams<'verifyOAuth'>['method']) => void;
     verifyFarcaster: () => void;
     verifyTelegram: (_: TelegramAuthResponse) => void;
+    verifyTelegramStatus: MutationStatus;
     onNewAuthState: (_: AuthState) => void;
     presentSignupUi: (_: AuthMethod, __: AuthStateSignup) => void;
     presentLoginUi: (_: AuthMethod, __: AuthStateLogin) => void;