@getpara/react-sdk-lite 2.11.0 → 2.13.0

package/dist/provider/providers/AuthProvider/AuthProvider.js

@@ -0,0 +1,261 @@
+"use client";
+import {
+  __async,
+  __spreadValues
+} from "../../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { useContext, useEffect, useRef } from "react";
+import { AuthMethod } from "@getpara/web-sdk";
+import { AuthContext } from "./AuthContext.js";
+import {
+  useAuthenticateWithEmailOrPhone,
+  useAuthenticateWithOAuth,
+  useCreateGuestWallets,
+  useSetup2fa
+} from "../../index.js";
+import { openPopup } from "../../../modal/utils/openPopup.js";
+import { useStore, store } from "../../stores/useStore.js";
+import { useGoBack } from "../../../modal/hooks/useGoBack.js";
+import { useUserAgent } from "@getpara/react-common";
+import parsePhoneNumberFromString from "libphonenumber-js";
+import { validateInput } from "../../../modal/utils/authInputHelpers.js";
+import { useInternalClient } from "../../hooks/utils/useInternalClient.js";
+const AuthProvider = ({ children, isTwoFactorAuthEnabled, defaultAuthIdentifier }) => {
+  const para = useInternalClient();
+  const refs = useStore((state) => state.refs);
+  const { createGuestWalletsAsync } = useCreateGuestWallets();
+  const { authenticateWithEmailOrPhoneAsync, isPending: isAuthenticatingWithEmailOrPhone } = useAuthenticateWithEmailOrPhone();
+  const { authenticateWithOAuthAsync, isPending: isAuthenticatingWithOAuth } = useAuthenticateWithOAuth();
+  const { setup2faAsync } = useSetup2fa();
+  const setIFrameUrl = useStore((state) => state.setIFrameUrl);
+  const setAuthMethod = useStore((state) => state.setAuthMethod);
+  const setShowPostAuthFlow = useStore((state) => state.setShowPostAuthFlow);
+  const setRecoverySecret = useStore((state) => state.setRecoverySecret);
+  const setTwoFactorAuthUri = useStore((state) => state.setTwoFactorAuthUri);
+  const setHasCreatedWallets = useStore((state) => state.setHasCreatedWallets);
+  const bareModal = useStore((state) => {
+    var _a;
+    return (_a = state.modalConfig) == null ? void 0 : _a.bareModal;
+  });
+  const setIsOpen = useStore((state) => state.setIsOpen);
+  const onWalletCreated = useStore((state) => {
+    var _a;
+    return (_a = state.modalConfig) == null ? void 0 : _a.onWalletCreated;
+  });
+  const { goBack } = useGoBack();
+  const userAgent = useUserAgent();
+  const paraState = useStore((state) => state.paraState);
+  const authStateInfo = paraState == null ? void 0 : paraState.authStateInfo;
+  const isAuthFlowActiveRef = useRef(false);
+  const lastAuthPhaseRef = useRef(null);
+  const lastSetIFrameUrlRef = useRef(null);
+  useEffect(() => {
+    const isMobile = (userAgent == null ? void 0 : userAgent.device.type) === "mobile";
+    const unsub = store.subscribe((state) => {
+      var _a, _b;
+      const info = (_a = state.paraState) == null ? void 0 : _a.authStateInfo;
+      const authPhase = (_b = state.paraState) == null ? void 0 : _b.authPhase;
+      if (!isAuthFlowActiveRef.current || !info || !authPhase) return;
+      if (authPhase === lastAuthPhaseRef.current) return;
+      lastAuthPhaseRef.current = authPhase;
+      if (info.verificationUrl) {
+        if (info.verificationUrl !== lastSetIFrameUrlRef.current) {
+          lastSetIFrameUrlRef.current = info.verificationUrl;
+          store.getState().setIFrameUrl(info.verificationUrl);
+        }
+        return;
+      }
+      const { passkeyUrl, passwordUrl, pinUrl, isPasskeySupported } = info;
+      const hasPassword = !!passwordUrl;
+      const hasPin = !!pinUrl;
+      const hasExactlyOnePasswordOrPin = hasPassword && !hasPin || !hasPassword && hasPin;
+      const shouldUseIFrame = !passkeyUrl || isMobile && !isPasskeySupported && hasExactlyOnePasswordOrPin;
+      if (shouldUseIFrame && (hasPassword || hasPin)) {
+        const biometricUrl = hasPassword ? passwordUrl : pinUrl;
+        if (biometricUrl !== lastSetIFrameUrlRef.current) {
+          lastSetIFrameUrlRef.current = biometricUrl;
+          store.getState().setAuthMethod(hasPassword ? AuthMethod.PASSWORD : AuthMethod.PIN);
+          store.getState().setIFrameUrl(biometricUrl);
+        }
+      }
+    });
+    return unsub;
+  }, [userAgent]);
+  useEffect(() => {
+    const triggerAuth = () => __async(void 0, null, function* () {
+      var _a;
+      if (!para) return;
+      if (defaultAuthIdentifier && ((_a = para.authInfo) == null ? void 0 : _a.identifier) !== defaultAuthIdentifier) {
+        const number = parsePhoneNumberFromString(defaultAuthIdentifier);
+        try {
+          const auth = validateInput(
+            number ? number.nationalNumber : defaultAuthIdentifier,
+            (number == null ? void 0 : number.countryCallingCode) ? `+${number == null ? void 0 : number.countryCallingCode}` : void 0,
+            number ? "phone" : "email"
+          );
+          yield para.setAuth(number ? { phone: defaultAuthIdentifier } : { email: defaultAuthIdentifier });
+          yield handleAuthenticateWithEmailOrPhone(auth);
+        } catch (err) {
+          console.error("invalid user identifier:", err.message);
+        }
+      }
+    });
+    triggerAuth();
+  }, []);
+  const handleVerification = (code) => __async(void 0, null, function* () {
+    if (!para) return;
+    yield para == null ? void 0 : para.verifyNewAccount({ verificationCode: code });
+  });
+  const setupBeforeAuth = () => {
+    setAuthMethod(null);
+    setShowPostAuthFlow(true);
+    isAuthFlowActiveRef.current = true;
+    lastAuthPhaseRef.current = null;
+    lastSetIFrameUrlRef.current = null;
+  };
+  const postAuth = (resp) => __async(void 0, null, function* () {
+    isAuthFlowActiveRef.current = false;
+    if (!resp) {
+      goBack();
+      return;
+    }
+    if (isTwoFactorAuthEnabled) {
+      yield setup2faAsync(void 0, {
+        onSuccess: (data) => {
+          if (!data.isSetup && data.uri) {
+            setTwoFactorAuthUri(data.uri);
+          }
+        }
+      });
+    }
+    if (resp == null ? void 0 : resp.recoverySecret) {
+      setRecoverySecret(resp.recoverySecret);
+    }
+    if (resp == null ? void 0 : resp.hasCreatedWallets) {
+      onWalletCreated == null ? void 0 : onWalletCreated({ recoverySecret: resp.recoverySecret });
+      setHasCreatedWallets(resp.hasCreatedWallets);
+    }
+  });
+  const handleAuthenticateWithEmailOrPhone = (auth) => __async(void 0, null, function* () {
+    setupBeforeAuth();
+    try {
+      const resp = yield authenticateWithEmailOrPhoneAsync({
+        auth,
+        sessionPollingCallbacks: {
+          onPoll: () => {
+            const isUsingIFrame = !!store.getState().iFrameUrl;
+            if (isUsingIFrame) {
+              return;
+            }
+            const authMethod = store.getState().authMethod;
+            if ((!refs.popupWindow.current || refs.popupWindow.current.closed) && authMethod !== null && authMethod !== AuthMethod.BASIC_LOGIN) {
+              setAuthMethod(null);
+            }
+          }
+        }
+      });
+      yield postAuth(resp);
+    } catch (e) {
+      isAuthFlowActiveRef.current = false;
+    }
+  });
+  const handleAuthenticateWithOAuth = (method) => __async(void 0, null, function* () {
+    setupBeforeAuth();
+    let shouldCancelAfterNextPoll = false;
+    let shouldCancel = false;
+    try {
+      const resp = yield authenticateWithOAuthAsync({
+        method,
+        redirectCallbacks: __spreadValues(__spreadValues({}, method !== "FARCASTER" && method !== "TELEGRAM" && {
+          onOAuthPopup: (window2) => {
+            refs.popupWindow.current = window2;
+          }
+        }), (method === "TELEGRAM" || method === "FARCASTER") && {
+          onOAuthUrl: (url) => {
+            setIFrameUrl(url);
+          }
+        }),
+        sessionPollingCallbacks: {
+          onPoll: () => {
+            const isUsingIFrame = !!store.getState().iFrameUrl;
+            if (isUsingIFrame) {
+              return;
+            }
+            const authMethod = store.getState().authMethod;
+            if ((!refs.popupWindow.current || refs.popupWindow.current.closed) && authMethod !== null && authMethod !== AuthMethod.BASIC_LOGIN) {
+              setAuthMethod(null);
+            }
+          }
+        },
+        oAuthPollingCallbacks: {
+          onPoll: () => {
+            if (!refs.popupWindow.current || refs.popupWindow.current.closed) {
+              shouldCancelAfterNextPoll = true;
+            }
+            if (shouldCancelAfterNextPoll) {
+              shouldCancel = true;
+            }
+          },
+          isCanceled: () => shouldCancel,
+          onCancel: () => {
+            goBack();
+          }
+        }
+      });
+      yield postAuth(resp);
+    } catch (e) {
+      isAuthFlowActiveRef.current = false;
+    }
+  });
+  const openBiometricUrl = (method) => {
+    var _a, _b, _c;
+    setAuthMethod(method);
+    const passkeyUrl = (_a = authStateInfo == null ? void 0 : authStateInfo.passkeyUrl) != null ? _a : null;
+    const passwordUrl = (_b = authStateInfo == null ? void 0 : authStateInfo.passwordUrl) != null ? _b : null;
+    const pinUrl = (_c = authStateInfo == null ? void 0 : authStateInfo.pinUrl) != null ? _c : null;
+    const isPassword = method === AuthMethod.PASSWORD;
+    const isPIN = method === AuthMethod.PIN;
+    if (isPassword || isPIN) {
+      const biometricUrl = isPassword ? passwordUrl : pinUrl;
+      setIFrameUrl(biometricUrl);
+      return;
+    }
+    if (typeof window !== "undefined" && passkeyUrl) {
+      refs.popupWindow.current = openPopup({
+        url: passkeyUrl,
+        target: "ParaPasskey",
+        type: "LOGIN_PASSKEY",
+        current: refs.popupWindow.current
+      });
+    }
+  };
+  const createGuestWallets = () => __async(void 0, null, function* () {
+    if (!bareModal) {
+      setIsOpen(false);
+    }
+    yield createGuestWalletsAsync(void 0);
+  });
+  const value = {
+    // Methods
+    verifyEmailOrPhone: {
+      verify: handleVerification,
+      isVerifying: false
+    },
+    authenticateWithEmailOrPhone: {
+      authenticate: handleAuthenticateWithEmailOrPhone,
+      isAuthenticating: isAuthenticatingWithEmailOrPhone
+    },
+    authenticateWithOAuth: {
+      authenticate: handleAuthenticateWithOAuth,
+      isAuthenticating: isAuthenticatingWithOAuth
+    },
+    openBiometricUrl,
+    createGuestWallets
+  };
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value, children });
+};
+const useAuth = () => useContext(AuthContext);
+export {
+  AuthProvider,
+  useAuth
+};

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

@@ -1,7 +1,7 @@
 import { PropsWithChildren } from 'react';
 import { TWalletType } from '@getpara/web-sdk';
 import { BalanceManagement, ChainManagement, CommonWallet, DisconnectBaseOptions, ExternalWalletContextType, MutationStatus } from '@getpara/react-common';
-import { ExternalWalletInfo, VerifyExternalWalletParams } from '@getpara/web-sdk';
+import { ExternalWalletInfo } from '@getpara/web-sdk';
 import { CosmosSignResult } from '@getpara/cosmos-wallet-connectors';
 export declare const useWalletDisplayHelpers: (wallet: CommonWallet | undefined) => {
     showExtension: boolean;
@@ -28,19 +28,23 @@ export declare const defaultExternalWallet: {
     switchChain: () => Promise<void>;
     setChainIdSwitchingTo: () => void;
     connectEmbeddedToExternalConnectors: () => Promise<void>;
-    verifyWalletSignature: () => Promise<any>;
     signMessage: () => Promise<any>;
     isSigningMessage: boolean;
     getWalletBalance: () => Promise<undefined>;
     requestInfo: (_: string) => Promise<ExternalWalletInfo>;
     disconnectBase: (_: string, __: TWalletType, ___?: DisconnectBaseOptions) => Promise<void>;
     connectFarcasterMiniApp: () => Promise<void>;
+    switchConnection: (_: {
+        type: TWalletType;
+        id: string;
+    }) => Promise<void>;
     verificationStage: undefined;
     evmDisconnectStatus: string;
     solanaDisconnectStatus: string;
     cosmosDisconnectStatus: string;
+    retryVerification: () => Promise<void>;
 };
-type Value = Omit<ExternalWalletContextType<CosmosSignResult>, 'disconnect' | 'disconnectStatus' | 'signVerificationMessage' | 'requestInfo' | 'disconnectBase'> & ChainManagement<string, void> & BalanceManagement & {
+type Value = Omit<ExternalWalletContextType<CosmosSignResult>, 'disconnect' | 'disconnectStatus' | 'signVerificationMessage' | 'requestInfo' | 'disconnectBase' | 'switchConnection'> & ChainManagement<string, void> & BalanceManagement & {
     wallet?: CommonWallet;
     qrUri?: string;
     chainIdSwitchingTo?: string;
@@ -63,14 +67,18 @@ type Value = Omit<ExternalWalletContextType<CosmosSignResult>, 'disconnect' | 'd
     setChainIdSwitchingTo: (chainId?: string) => void;
     connectEmbeddedToExternalConnectors: () => Promise<void>;
     isSigningMessage: boolean;
-    verifyWalletSignature: () => Promise<VerifyExternalWalletParams | undefined>;
     requestInfo: (_: string, __: TWalletType) => Promise<ExternalWalletInfo>;
     disconnectBase: (_: string, __: TWalletType, ___?: DisconnectBaseOptions) => Promise<void>;
     connectFarcasterMiniApp: () => Promise<void>;
+    switchConnection: (_: {
+        type: TWalletType;
+        id: string;
+    }) => Promise<void>;
     verificationStage?: 'verifying' | 'switchingChain';
     evmDisconnectStatus: MutationStatus;
     solanaDisconnectStatus: MutationStatus;
     cosmosDisconnectStatus: MutationStatus;
+    retryVerification: () => Promise<void>;
 };
 export declare const ExternalWalletContext: import("react").Context<Value>;
 export declare function ExternalWalletProvider({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;