@getpara/react-sdk 2.0.0-dev.3 → 2.0.0-dev.5

package/dist/provider/providers/AccountLinkProvider.js

@@ -1,452 +0,0 @@
-"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 }) => {
-  var _a;
-  const para = useInternalClient();
-  const queryClient = useQueryClient();
-  const { embedded } = 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 = !!(embedded == null ? void 0 : embedded.isConnected) && !(embedded == null ? void 0 : embedded.isGuestMode) && (!((_a = para.authInfo) == null ? void 0 : _a.externalWallet) || includeWalletVerification);
-  const [accountLinkInProgress, setAccountLinkInProgress] = useState(
-    coreAccountLinkInProgress || void 0
-  );
-  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.internalId;
-          const type = args.externalWallet.type;
-          if (providerId === (connectedWallet == null ? void 0 : connectedWallet.internalId)) {
-            throw new Error(`Cannot link the currently connected external wallet: ${providerId}`);
-          }
-          setAccountLinkInProgress({
-            type: "EXTERNAL_WALLET",
-            pendingWalletProvider: providerId,
-            pendingWalletType: type
-          });
-          const linkWallet = wallets.find((w) => w.internalId === providerId);
-          if (!linkWallet) {
-            throw new Error(`wallet not installed: ${providerId}`);
-          }
-          openModal({ step: !type ? ModalStep.EX_WALLET_NETWORK_SELECT : ModalStep.ACCOUNT_PROFILE_ADD });
-          if (!type) {
-            return;
-          }
-          try {
-            const externalWallet = yield externalWalletRequestInfo(providerId, type);
-            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 _a2;
-          return !!((_a2 = refs.popupWindow.current) == null ? void 0 : _a2.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 || 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

@@ -1,37 +0,0 @@
-import { BiometricHints } from '@getpara/react-common';
-import { PropsWithChildren } from 'react';
-import { AuthMethod, CoreMethodParams, AuthState, AuthStateSignup, AuthStateLogin } from '@getpara/web-sdk';
-import { ParaModalProps } from '../../modal/types/modalProps.js';
-import { TelegramAuthResponse, VerifiedAuth } from '@getpara/user-management-client';
-import { MutationStatus } from '@tanstack/react-query';
-type Value = {
-    signUpOrLogIn: (_: VerifiedAuth) => void;
-    isSignUpOrLogInPending: boolean;
-    verifyNewAccount: (_: string) => void;
-    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;
-    isSetup2faPending: boolean;
-    createGuestWallets: () => void;
-    isCreateGuestWalletsPending: boolean;
-    logout: () => void;
-    biometricHints?: BiometricHints;
-};
-type Props = PropsWithChildren<{
-    is2faEnabled?: boolean;
-    isRecoverySecretStepEnabled?: boolean;
-    overrides?: {
-        login?: ParaModalProps['loginTransitionOverride'];
-        createWallets?: ParaModalProps['createWalletOverride'];
-    };
-}>;
-export declare const AuthContext: import("react").Context<Value>;
-export declare function AuthProvider({ children, is2faEnabled, isRecoverySecretStepEnabled, overrides, }: Props): import("react/jsx-runtime").JSX.Element;
-export declare const useAuthActions: () => Value;
-export {};