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

package/dist/provider/providers/AccountLinkProvider.js

@@ -0,0 +1,452 @@
+"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

@@ -0,0 +1,38 @@
+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;
+    isOAuthReady?: boolean;
+};
+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 {};