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

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

@@ -2,18 +2,24 @@ 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, VerifyExternalWalletParams } from '@getpara/user-management-client';
+import { TelegramAuthResponse, VerifiedAuth } from '@getpara/user-management-client';
+import { MutationStatus } from '@tanstack/react-query';
 type Value = {
-    signUpOrLogIn: [(_: VerifiedAuth) => void, boolean];
-    verifyNewAccount: [(_: string) => void, boolean, Error | null];
-    verifyOAuth: (_: CoreMethodParams<'verifyOAuthV2'>['method']) => void;
+    signUpOrLogIn: (_: VerifiedAuth) => void;
+    isSignUpOrLogInPending: boolean;
+    verifyNewAccount: (_: string) => void;
+    verifyNewAccountStatus: MutationStatus;
+    verifyNewAccountError: Error | null;
+    verifyOAuth: (_: CoreMethodParams<'verifyOAuth'>['method']) => void;
     verifyFarcaster: () => void;
     verifyTelegram: (_: TelegramAuthResponse) => void;
-    verifyExternalWallet: (_: VerifyExternalWalletParams) => void;
+    verifyTelegramStatus: MutationStatus;
     onNewAuthState: (_: AuthState) => void;
     presentSignupUi: (_: AuthMethod, __: AuthStateSignup) => void;
     presentLoginUi: (_: AuthMethod, __: AuthStateLogin) => void;
-    setup2fa: [boolean];
+    isSetup2faPending: boolean;
+    createGuestWallets: () => void;
+    isCreateGuestWalletsPending: boolean;
     logout: () => void;
     biometricHints?: BiometricHints;
 };

package/dist/provider/providers/AuthProvider.js

@@ -0,0 +1,523 @@
+"use client";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { useUserAgent } from "@getpara/react-common";
+import { createContext, useCallback, useContext, useEffect, useMemo } from "react";
+import { useModalStore } from "../../modal/stores/index.js";
+import { ModalStep } from "../../modal/utils/steps.js";
+import {
+  useSignUpOrLogIn,
+  useVerifyNewAccount,
+  useWaitForSignup,
+  useWaitForLogin,
+  useWaitForWalletCreation,
+  useVerifyOAuth,
+  useVerifyFarcaster,
+  useVerifyTelegram,
+  useSetup2fa,
+  useLogout,
+  useCreateGuestWallets
+} from "../index.js";
+import { DEFAULTS } from "../../modal/constants/defaults.js";
+import { openPopup } from "../../modal/utils/openPopup.js";
+import {
+  AuthMethod,
+  entityToWallet
+} from "@getpara/web-sdk";
+import { useInternalClient } from "../../provider/hooks/utils/useInternalClient.js";
+import { useGoBack } from "../../modal/hooks/useGoBack.js";
+import { isExternalWallet } from "@getpara/user-management-client";
+import { routeMobileExternalWallet } from "../../modal/utils/routeMobileExternalWallet.js";
+import { useStore } from "../stores/useStore.js";
+import { useFormattedBiometricHints } from "../hooks/utils/useFormattedBiometricHints.js";
+import { useQueryClient } from "@tanstack/react-query";
+const AuthContext = createContext({
+  signUpOrLogIn: () => {
+  },
+  isSignUpOrLogInPending: false,
+  verifyNewAccount: () => {
+  },
+  verifyNewAccountStatus: "idle",
+  verifyNewAccountError: null,
+  verifyOAuth: () => {
+  },
+  verifyFarcaster: () => {
+  },
+  verifyTelegram: () => {
+  },
+  verifyTelegramStatus: "idle",
+  onNewAuthState: () => {
+  },
+  isSetup2faPending: false,
+  presentSignupUi: () => {
+  },
+  presentLoginUi: () => {
+  },
+  createGuestWallets: () => {
+  },
+  isCreateGuestWalletsPending: false,
+  logout: () => {
+  }
+});
+function AuthProvider({
+  children,
+  is2faEnabled = false,
+  isRecoverySecretStepEnabled = false,
+  overrides = {}
+}) {
+  const queryClient = useQueryClient();
+  const para = useInternalClient();
+  const userAgent = useUserAgent();
+  const onLoginRef = useStore((state) => state.onLoginRef);
+  const setIsOpen = useStore((state) => state.setIsOpen);
+  const bareModal = useStore((state) => {
+    var _a;
+    return (_a = state.modalConfig) == null ? void 0 : _a.bareModal;
+  });
+  const refs = useModalStore((state) => state.refs);
+  const setFlow = useModalStore((state) => state.setFlow);
+  const currentStep = useModalStore((state) => state.step);
+  const setStep = useModalStore((state) => state.setStep);
+  const setAuthStepRoute = useModalStore((state) => state.setAuthStepRoute);
+  const setIFrameUrl = useModalStore((state) => state.setIFrameUrl);
+  const iFrameUrl = useModalStore((state) => state.iFrameUrl);
+  const loginState = useModalStore((state) => state.getLoginState());
+  const signupState = useModalStore((state) => state.getSignupState());
+  const setAuthState = useModalStore((state) => state.setAuthState);
+  const setFarcasterConnectUri = useModalStore((state) => state.setFarcasterConnectUri);
+  const setTwoFactorStatus = useModalStore((state) => state.setTwoFactorStatus);
+  const setRecoveryShare = useModalStore((state) => state.setRecoveryShare);
+  const authStepRoute = useModalStore((state) => state.authStepRoute);
+  const isIFrameReady = useModalStore((state) => state.isIFrameReady);
+  const goBack = useGoBack();
+  const { mutate: mutateSignUpOrLogIn, isPending: isSignUpOrLogInPending } = useSignUpOrLogIn();
+  const {
+    mutate: mutateVerifyNewAccount,
+    status: verifyNewAccountStatus,
+    error: verifyNewAccountError
+  } = useVerifyNewAccount();
+  const { mutate: mutateVerifyOAuth } = useVerifyOAuth();
+  const { mutate: mutateVerifyFarcaster } = useVerifyFarcaster();
+  const { mutate: mutateVerifyTelegram, status: verifyTelegramStatus } = useVerifyTelegram();
+  const { mutate: mutateWaitForLogin } = useWaitForLogin();
+  const { mutate: mutateWaitForSignup } = useWaitForSignup();
+  const { mutateAsync: mutateAsyncWaitForWalletCreation } = useWaitForWalletCreation();
+  const { mutate: mutateSetup2fa, isPending: isSetup2faPending } = useSetup2fa();
+  const { mutate: mutateCreateGuestWallets, isPending: isCreateGuestWalletsPending } = useCreateGuestWallets();
+  const { mutate: mutateLogout } = useLogout();
+  const { data: biometricHints } = useFormattedBiometricHints();
+  const goBackIfPopupClosedOnSteps = (steps) => {
+    var _a;
+    if (((_a = refs.popupWindow.current) == null ? void 0 : _a.closed) && (!refs.currentStep.current || steps.includes(refs.currentStep.current))) {
+      refs.popupWindow.current = null;
+      goBack();
+    }
+  };
+  const cancelIfExitedSteps = (steps) => {
+    const stepNow = refs.currentStep.current;
+    return !!stepNow && !steps.includes(stepNow);
+  };
+  const signup = () => {
+    if (typeof window !== "undefined") {
+      refs.poll.current = {
+        action: "signup",
+        timeout: window == null ? void 0 : window.setTimeout(() => __async(this, null, function* () {
+          mutateWaitForSignup(
+            {
+              isCanceled: () => cancelIfExitedSteps([
+                ModalStep.BIOMETRIC_CREATION,
+                ModalStep.AWAITING_BIOMETRIC_CREATION,
+                ModalStep.PASSWORD_CREATION
+              ]),
+              onPoll: () => {
+                goBackIfPopupClosedOnSteps([ModalStep.AWAITING_BIOMETRIC_CREATION]);
+              }
+            },
+            {
+              onSuccess: () => {
+                if (para.isNoWalletConfig) {
+                  onLoginComplete({
+                    on2faSetupOrError: () => setStep(ModalStep.LOGIN_DONE),
+                    on2faNotSetup: () => setStep(ModalStep.SETUP_2FA)
+                  });
+                } else {
+                  createWallets();
+                }
+              },
+              onError: () => {
+                if (refs.currentStep.current && [ModalStep.AWAITING_BIOMETRIC_CREATION, ModalStep.PASSWORD_CREATION].includes(refs.currentStep.current)) {
+                  setStep(ModalStep.BIOMETRIC_CREATION);
+                }
+              },
+              onSettled: () => {
+                var _a;
+                window == null ? void 0 : window.clearTimeout((_a = refs.poll.current) == null ? void 0 : _a.timeout);
+                refs.poll.current = null;
+                refs.popupWindow.current = null;
+              }
+            }
+          );
+        }), DEFAULTS.POLLING_INTERVAL_MS)
+      };
+    }
+  };
+  const presentSignupUi = useCallback(
+    (method, authState) => {
+      switch (method) {
+        case AuthMethod.PASSKEY:
+          if (refs.currentStep.current !== ModalStep.AWAITING_BIOMETRIC_CREATION) {
+            setStep(ModalStep.AWAITING_BIOMETRIC_CREATION);
+          }
+          refs.popupWindow.current = openPopup({
+            url: authState.passkeyUrl,
+            target: "ParaPasskey",
+            type: "CREATE_PASSKEY",
+            current: refs.popupWindow.current
+          });
+          break;
+        case AuthMethod.PASSWORD:
+          if (isIFrameReady) {
+            setStep(ModalStep.PASSWORD_CREATION);
+          } else {
+            setIFrameUrl(authState.passwordUrl);
+            setAuthStepRoute(ModalStep.PASSWORD_CREATION);
+          }
+          break;
+      }
+    },
+    [isIFrameReady]
+  );
+  const login = (authState) => {
+    if (authState.isWalletSelectionNeeded || authState.passkeyUrl) {
+      setStep(ModalStep.BIOMETRIC_LOGIN);
+    } else {
+      setIFrameUrl(authState.passwordUrl);
+      setStep(ModalStep.EMBEDDED_PASSWORD_LOGIN);
+    }
+    refs.poll.current = {
+      action: "login",
+      timeout: window == null ? void 0 : window.setTimeout(() => __async(this, null, function* () {
+        mutateWaitForLogin(
+          {
+            isCanceled: () => cancelIfExitedSteps([
+              ModalStep.BIOMETRIC_LOGIN,
+              ModalStep.EMBEDDED_PASSWORD_LOGIN,
+              ModalStep.AWAITING_BIOMETRIC_LOGIN,
+              ModalStep.AWAITING_PASSWORD_LOGIN
+            ]),
+            onPoll: () => {
+              goBackIfPopupClosedOnSteps([
+                ModalStep.AWAITING_BIOMETRIC_LOGIN,
+                ModalStep.AWAITING_PASSWORD_LOGIN,
+                ModalStep.EMBEDDED_PASSWORD_LOGIN
+              ]);
+            }
+          },
+          {
+            onSuccess: ({ needsWallet }) => {
+              if (needsWallet && !para.isNoWalletConfig) {
+                createWallets();
+              } else {
+                onLoginComplete({
+                  on2faSetupOrError: () => setStep(ModalStep.LOGIN_DONE),
+                  on2faNotSetup: () => setStep(ModalStep.SETUP_2FA)
+                });
+              }
+            },
+            onSettled: () => {
+              var _a;
+              window == null ? void 0 : window.clearTimeout((_a = refs.poll.current) == null ? void 0 : _a.timeout);
+              refs.poll.current = null;
+              refs.popupWindow.current = null;
+            }
+          }
+        );
+      }), DEFAULTS.LOGGIN_POLLING_DELAY_MS)
+    };
+  };
+  const presentLoginUi = useCallback(
+    (method, authState) => {
+      const isPasskey = method === AuthMethod.PASSKEY, isPassword = !isPasskey;
+      if (overrides.login) {
+        function loginOverride() {
+          return __async(this, null, function* () {
+            var _a, _b;
+            yield (_a = overrides == null ? void 0 : overrides.login) == null ? void 0 : _a.call(overrides, para);
+            yield (_b = onLoginRef.current) == null ? void 0 : _b.call(onLoginRef);
+            yield onLoginComplete();
+          });
+        }
+        loginOverride();
+        return;
+      }
+      refs.popupWindow.current = openPopup({
+        url: isPassword ? authState.passwordUrl : authState.passkeyUrl,
+        target: isPassword ? "ParaPassword" : "ParaPasskey",
+        type: isPassword ? "LOGIN_PASSWORD" : "LOGIN_PASSKEY",
+        current: refs.popupWindow.current
+      });
+      setStep(isPassword ? ModalStep.AWAITING_PASSWORD_LOGIN : ModalStep.AWAITING_BIOMETRIC_LOGIN);
+    },
+    [loginState, biometricHints]
+  );
+  const onNewAuthState = (authState) => __async(this, null, function* () {
+    setAuthState(authState);
+    switch (authState.stage) {
+      case "verify":
+        if (isExternalWallet(authState.auth) && authState.signatureVerificationMessage) {
+          setStep(ModalStep.EXTERNAL_WALLET_VERIFICATION);
+        } else {
+          setStep(ModalStep.VERIFICATIONS);
+        }
+        break;
+      case "login":
+        login(authState);
+        break;
+      case "signup":
+        {
+          const isPassword = !!authState.passwordUrl, isPasswordOnly = isPassword && (!authState.passkeyUrl || (userAgent == null ? void 0 : userAgent.device.type) === "mobile" && !authState.isPasskeySupported);
+          if (isPassword) {
+            setIFrameUrl(authState.passwordUrl);
+          }
+          signup();
+          if (isPasswordOnly) {
+            presentSignupUi(AuthMethod.PASSWORD, authState);
+          } else {
+            setStep(ModalStep.BIOMETRIC_CREATION);
+          }
+        }
+        break;
+    }
+  });
+  const signUpOrLogIn = (auth) => __async(this, null, function* () {
+    mutateSignUpOrLogIn(
+      { auth, useShortUrls: true },
+      {
+        onSuccess: onNewAuthState
+      }
+    );
+  });
+  const verifyNewAccount = (verificationCode) => __async(this, null, function* () {
+    mutateVerifyNewAccount(
+      { verificationCode, useShortUrls: true },
+      {
+        onSuccess: onNewAuthState
+      }
+    );
+  });
+  const verifyOAuth = (method) => __async(this, null, function* () {
+    setStep(ModalStep.AWAITING_OAUTH);
+    mutateVerifyOAuth(
+      {
+        method,
+        isCanceled: () => {
+          var _a;
+          return ((_a = refs.popupWindow.current) == null ? void 0 : _a.closed) || cancelIfExitedSteps([ModalStep.AWAITING_OAUTH]);
+        },
+        onPoll: () => {
+          goBackIfPopupClosedOnSteps([ModalStep.AWAITING_OAUTH]);
+        },
+        onOAuthUrl: (oAuthUrl) => {
+          refs.popupWindow.current = openPopup({
+            url: oAuthUrl,
+            target: `${method}AuthPopup`,
+            type: "OAUTH",
+            current: refs.popupWindow.current
+          });
+        },
+        useShortUrls: true
+      },
+      {
+        onSuccess: onNewAuthState,
+        onError: () => {
+          goBackIfPopupClosedOnSteps([ModalStep.AWAITING_OAUTH]);
+        }
+      }
+    );
+  });
+  const verifyFarcaster = () => __async(this, null, function* () {
+    setStep(ModalStep.FARCASTER_OAUTH);
+    mutateVerifyFarcaster(
+      {
+        isCanceled: () => refs.currentStep.current !== ModalStep.FARCASTER_OAUTH,
+        onConnectUri: (connectUri) => {
+          setFarcasterConnectUri(connectUri);
+          routeMobileExternalWallet(connectUri);
+        },
+        useShortUrls: true
+      },
+      {
+        onSuccess: onNewAuthState,
+        onError: () => {
+          if (refs.currentStep.current === ModalStep.FARCASTER_OAUTH) {
+            goBack();
+          }
+        }
+      }
+    );
+  });
+  const verifyTelegram = (telegramAuthResponse) => __async(this, null, function* () {
+    mutateVerifyTelegram(
+      {
+        telegramAuthResponse,
+        useShortUrls: true
+      },
+      {
+        onSuccess: onNewAuthState
+      }
+    );
+  });
+  const onLoginComplete = useCallback(
+    (..._0) => __async(this, [..._0], function* ({
+      on2faSetupOrError,
+      on2faNotSetup
+    } = {}) {
+      var _a;
+      yield queryClient.invalidateQueries({ queryKey: ["isFullyLoggedIn"] });
+      setAuthState();
+      yield (_a = onLoginRef.current) == null ? void 0 : _a.call(onLoginRef);
+      if (is2faEnabled) {
+        mutateSetup2fa(void 0, {
+          onSuccess: (status) => {
+            setTwoFactorStatus(status);
+            if (!status.isSetup && !!status.uri) {
+              on2faNotSetup == null ? void 0 : on2faNotSetup();
+            } else {
+              on2faSetupOrError == null ? void 0 : on2faSetupOrError();
+            }
+          },
+          onError: () => {
+            on2faSetupOrError == null ? void 0 : on2faSetupOrError();
+          }
+        });
+      } else {
+        on2faSetupOrError == null ? void 0 : on2faSetupOrError();
+      }
+    }),
+    [is2faEnabled]
+  );
+  const createWallets = useCallback(() => __async(this, null, function* () {
+    var _a;
+    if (refs.currentStep.current !== ModalStep.AWAITING_WALLET_CREATION) {
+      setStep(ModalStep.AWAITING_WALLET_CREATION);
+    }
+    let recoverySecret, walletIds;
+    try {
+      if (overrides.createWallets) {
+        ({ recoverySecret, walletIds } = yield (_a = overrides == null ? void 0 : overrides.createWallets) == null ? void 0 : _a.call(overrides, para));
+        const fetchedWallets = (yield para.fetchWallets()).filter((wallet) => !!wallet.address);
+        const newWallets = {};
+        for (const wallet of fetchedWallets) {
+          newWallets[wallet.id] = __spreadProps(__spreadValues({}, entityToWallet(wallet)), {
+            signer: ""
+          });
+        }
+        para.setWallets(newWallets);
+      } else {
+        ({ recoverySecret, walletIds } = yield mutateAsyncWaitForWalletCreation({
+          isCanceled: () => false
+        }));
+      }
+      if (walletIds) {
+        yield para.setCurrentWalletIds(walletIds);
+      }
+      if (recoverySecret && isRecoverySecretStepEnabled) {
+        setRecoveryShare(recoverySecret);
+      }
+      setStep(recoverySecret && isRecoverySecretStepEnabled ? ModalStep.SECRET : ModalStep.WALLET_CREATION_DONE);
+      onLoginComplete();
+    } catch (e) {
+    }
+  }), [para, isRecoverySecretStepEnabled, overrides == null ? void 0 : overrides.createWallets]);
+  const createGuestWallets = () => {
+    if (bareModal) {
+      setFlow("guest");
+      setStep(ModalStep.AWAITING_GUEST_WALLET_CREATION);
+    } else {
+      setIsOpen(false);
+    }
+    mutateCreateGuestWallets(void 0, {
+      onSuccess: () => {
+      },
+      onSettled: () => {
+      }
+    });
+  };
+  const logout = () => {
+    mutateLogout();
+  };
+  const isPasswordIFrameLoading = !!iFrameUrl && iFrameUrl === (signupState == null ? void 0 : signupState.passwordUrl) && !isIFrameReady;
+  const value = useMemo(
+    () => ({
+      presentSignupUi,
+      presentLoginUi,
+      signUpOrLogIn,
+      isSignUpOrLogInPending,
+      verifyNewAccount,
+      verifyNewAccountStatus: isPasswordIFrameLoading ? "pending" : verifyNewAccountStatus,
+      verifyNewAccountError,
+      verifyOAuth,
+      verifyFarcaster,
+      verifyTelegram,
+      verifyTelegramStatus,
+      onNewAuthState,
+      isSetup2faPending,
+      createGuestWallets,
+      isCreateGuestWalletsPending,
+      logout,
+      biometricHints: biometricHints || void 0
+    }),
+    [
+      presentSignupUi,
+      presentLoginUi,
+      signUpOrLogIn,
+      isSignUpOrLogInPending,
+      verifyNewAccount,
+      verifyNewAccountStatus,
+      isPasswordIFrameLoading,
+      verifyNewAccountError,
+      verifyOAuth,
+      verifyFarcaster,
+      verifyTelegram,
+      verifyTelegramStatus,
+      onNewAuthState,
+      isSetup2faPending,
+      createGuestWallets,
+      isCreateGuestWalletsPending,
+      logout,
+      biometricHints
+    ]
+  );
+  useEffect(() => {
+    if (!!authStepRoute && isIFrameReady && refs.currentStep.current !== authStepRoute) {
+      setTimeout(() => {
+        setStep(authStepRoute);
+      }, 200);
+    }
+  }, [authStepRoute, isIFrameReady]);
+  useEffect(() => {
+    refs.currentStep.current = currentStep;
+  }, [currentStep]);
+  useEffect(() => {
+    if (refs.currentStep.current === ModalStep.AWAITING_GUEST_WALLET_CREATION && !isCreateGuestWalletsPending) {
+      setStep(ModalStep.ACCOUNT_MAIN);
+    }
+  }, [isCreateGuestWalletsPending]);
+  useEffect(() => {
+    return () => {
+      var _a;
+      window == null ? void 0 : window.clearTimeout((_a = refs.poll.current) == null ? void 0 : _a.timeout);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value, children });
+}
+const useAuthActions = () => useContext(AuthContext);
+export {
+  AuthContext,
+  AuthProvider,
+  useAuthActions
+};

package/dist/provider/providers/CosmosExternalWalletProvider.js

@@ -0,0 +1,66 @@
+"use client";
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { memo, useEffect, useMemo } from "react";
+import { useStore } from "../stores/useStore.js";
+import { getParaCosmosConnector } from "../external/getParaCosmosConnector.js";
+function CosmosExternalWalletProvider(_a) {
+  var _b = _a, {
+    children,
+    isUsing,
+    wallets: walletsFromProps
+  } = _b, rest = __objRest(_b, [
+    "children",
+    "isUsing",
+    "wallets"
+  ]);
+  const setCosmosContext = useStore((state) => state.setCosmosContext);
+  const setCosmosProvider = useStore((state) => state.setCosmosProvider);
+  const CosmosProvider = useStore((state) => state.CosmosProvider);
+  const setCosmosWallets = useStore((state) => state.setCosmosWallets);
+  const cosmosWallets = useStore((state) => state.cosmosWallets);
+  const isLoadingLib = useStore((state) => state.isLoadingCosmosLib);
+  const setIsLoadingLib = useStore((state) => state.setIsLoadingCosmosLib);
+  const filteredWallets = useMemo(
+    () => cosmosWallets.filter((w) => walletsFromProps.includes(w().id.toUpperCase())),
+    [cosmosWallets, walletsFromProps]
+  );
+  useEffect(() => {
+    const loadLib = () => __async(this, null, function* () {
+      if (CosmosProvider) {
+        return;
+      }
+      const { Provider, context, wallets } = yield getParaCosmosConnector();
+      if (Provider) {
+        setCosmosProvider(Provider);
+      }
+      if (wallets) {
+        setCosmosWallets(wallets);
+      }
+      if (context) {
+        setCosmosContext(context);
+      }
+      setIsLoadingLib(false);
+    });
+    loadLib();
+  }, []);
+  if (isLoadingLib) {
+    return null;
+  }
+  if (CosmosProvider) {
+    return /* @__PURE__ */ jsx(CosmosProvider, __spreadProps(__spreadValues({}, rest), { config: __spreadProps(__spreadValues({}, rest == null ? void 0 : rest.config), { wallets: filteredWallets }), children }));
+  } else if (isUsing) {
+    console.warn("@getpara/cosmos-wallet-connectors is required to use an external Cosmos wallet.");
+  }
+  return children;
+}
+const MemoizedCosmosExternalWalletProvider = memo(CosmosExternalWalletProvider);
+export {
+  CosmosExternalWalletProvider,
+  MemoizedCosmosExternalWalletProvider
+};

package/dist/provider/providers/EvmExternalWalletProvider.js

@@ -0,0 +1,74 @@
+"use client";
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useMemo } from "react";
+import { getParaEvmConnector } from "../external/getParaEvmConnector.js";
+import { useStore } from "../stores/useStore.js";
+function EvmExternalWalletProvider(_a) {
+  var _b = _a, {
+    children,
+    isUsing,
+    wallets: walletsFromProps
+  } = _b, rest = __objRest(_b, [
+    "children",
+    "isUsing",
+    "wallets"
+  ]);
+  const setEvmContext = useStore((state) => state.setEvmContext);
+  const setEvmProvider = useStore((state) => state.setEvmProvider);
+  const EvmProvider = useStore((state) => state.EvmProvider);
+  const setEvmWallets = useStore((state) => state.setEvmWallets);
+  const evmWallets = useStore((state) => state.evmWallets);
+  const isLoadingLib = useStore((state) => state.isLoadingEvmLib);
+  const setIsLoadingLib = useStore((state) => state.setIsLoadingEvmLib);
+  const filteredWallets = useMemo(
+    () => evmWallets.filter(
+      (w) => {
+        var _a2, _b2, _c, _d;
+        return walletsFromProps.includes(
+          w({
+            appName: (_b2 = (_a2 = rest == null ? void 0 : rest.config) == null ? void 0 : _a2.appName) != null ? _b2 : "",
+            projectId: (_d = (_c = rest == null ? void 0 : rest.config) == null ? void 0 : _c.projectId) != null ? _d : ""
+          }).id.toUpperCase()
+        );
+      }
+    ),
+    [evmWallets, walletsFromProps]
+  );
+  useEffect(() => {
+    const loadLib = () => __async(this, null, function* () {
+      if (EvmProvider) {
+        return;
+      }
+      const { Provider, context, wallets } = yield getParaEvmConnector();
+      if (Provider) {
+        setEvmProvider(Provider);
+      }
+      if (wallets) {
+        setEvmWallets(wallets);
+      }
+      if (context) {
+        setEvmContext(context);
+      }
+      setIsLoadingLib(false);
+    });
+    loadLib();
+  }, []);
+  if (isLoadingLib) {
+    return null;
+  }
+  if (EvmProvider) {
+    return /* @__PURE__ */ jsx(EvmProvider, __spreadProps(__spreadValues({}, rest), { config: __spreadProps(__spreadValues({}, rest == null ? void 0 : rest.config), { wallets: filteredWallets }), children }));
+  } else if (isUsing) {
+    console.warn("@getpara/evm-wallet-connectors is required to use an external EVM wallet.");
+  }
+  return children;
+}
+export {
+  EvmExternalWalletProvider
+};