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

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

@@ -1,5 +1,13 @@
 import { PropsWithChildren } from 'react';
-import type { CommonChain, CommonWallet } from '@getpara/react-common';
+import { TWalletType } from '@getpara/web-sdk';
+import { BalanceManagement, ChainManagement, CommonWallet, ExternalWalletContextType, TExternalWallet } from '@getpara/react-common';
+import { ExternalWalletInfo, VerifyExternalWalletParams } from '@getpara/web-sdk';
+import { CosmosSignResult } from '@getpara/cosmos-wallet-connectors';
+export declare const useWalletDisplayHelpers: (wallet: CommonWallet | undefined) => {
+    showExtension: boolean;
+    showMobile: boolean;
+    isCosmosMobileWallet: boolean;
+};
 export declare const defaultExternalWallet: {
     wallets: never[];
     chains: never[];
@@ -10,7 +18,6 @@ export declare const defaultExternalWallet: {
     walletDisplayHelpers: {
         showExtension: boolean;
         showMobile: boolean;
-        isSolanaMobileIOS: boolean;
         isCosmosMobileWallet: boolean;
     };
     username: undefined;
@@ -20,60 +27,33 @@ export declare const defaultExternalWallet: {
     switchChain: () => Promise<void>;
     setChainIdSwitchingTo: () => void;
     connectEmbeddedToExternalConnectors: () => Promise<void>;
-    verifyWalletSignature: () => Promise<{}>;
+    verifyWalletSignature: () => Promise<any>;
+    signMessage: () => Promise<any>;
+    isSigningMessage: boolean;
+    getWalletBalance: () => Promise<undefined>;
+    requestInfo: (_: TExternalWallet) => Promise<ExternalWalletInfo>;
+    disconnectBase: (_: TExternalWallet) => Promise<void>;
 };
-export declare const ExternalWalletContext: import("react").Context<{
-    wallets: CommonWallet[];
-    chains: CommonChain[];
-    chainId?: string;
+type Value = Omit<ExternalWalletContextType<CosmosSignResult>, 'disconnect' | 'signVerificationMessage' | 'requestInfo'> & ChainManagement<string, void> & BalanceManagement & {
     wallet?: CommonWallet;
     qrUri?: string;
     chainIdSwitchingTo?: string;
     walletDisplayHelpers: {
         showExtension: boolean;
         showMobile: boolean;
-        isSolanaMobileIOS: boolean;
         isCosmosMobileWallet: boolean;
     };
     username?: string;
     avatar?: string;
     connectExternalWallet: (wallet: CommonWallet, isMobile?: boolean, isManualWalletConnect?: boolean) => Promise<void>;
     disconnectExternalWallet: () => Promise<void>;
-    switchChain: (chainId: string) => Promise<void>;
     setChainIdSwitchingTo: (chainId?: string) => void;
     connectEmbeddedToExternalConnectors: () => Promise<void>;
-    verifyWalletSignature: () => Promise<{
-        address?: string;
-        signature?: string;
-        cosmosPublicKeyHex?: string;
-        cosmosSigner?: string;
-    } | undefined>;
-}>;
-export declare function ExternalWalletProvider({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
-export declare const useExternalWallets: () => {
-    wallets: CommonWallet[];
-    chains: CommonChain[];
-    chainId?: string;
-    wallet?: CommonWallet;
-    qrUri?: string;
-    chainIdSwitchingTo?: string;
-    walletDisplayHelpers: {
-        showExtension: boolean;
-        showMobile: boolean;
-        isSolanaMobileIOS: boolean;
-        isCosmosMobileWallet: boolean;
-    };
-    username?: string;
-    avatar?: string;
-    connectExternalWallet: (wallet: CommonWallet, isMobile?: boolean, isManualWalletConnect?: boolean) => Promise<void>;
-    disconnectExternalWallet: () => Promise<void>;
-    switchChain: (chainId: string) => Promise<void>;
-    setChainIdSwitchingTo: (chainId?: string) => void;
-    connectEmbeddedToExternalConnectors: () => Promise<void>;
-    verifyWalletSignature: () => Promise<{
-        address?: string;
-        signature?: string;
-        cosmosPublicKeyHex?: string;
-        cosmosSigner?: string;
-    } | undefined>;
+    isSigningMessage: boolean;
+    verifyWalletSignature: () => Promise<VerifyExternalWalletParams | undefined>;
+    requestInfo: (_: TExternalWallet, __: TWalletType) => Promise<ExternalWalletInfo>;
 };
+export declare const ExternalWalletContext: import("react").Context<Value>;
+export declare function ExternalWalletProvider({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+export declare const useExternalWallets: () => Value;
+export {};

package/dist/provider/providers/ExternalWalletProvider.js

@@ -0,0 +1,596 @@
+"use client";
+import {
+  __async,
+  __spreadValues
+} from "../../chunk-MMUBH76A.js";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import { isMobile, truncateAddress } from "@getpara/web-sdk";
+import { useInternalClient } from "../hooks/utils/useInternalClient.js";
+import { useStore } from "../stores/useStore.js";
+import { ModalStep } from "../../modal/index.js";
+import { useModalStore } from "../../modal/stores/index.js";
+import { useVerifyExternalWallet, useWalletState } from "../hooks/index.js";
+import {
+  COSMOS_WALLETS,
+  EVM_WALLETS,
+  SOLANA_WALLETS
+} from "@getpara/web-sdk";
+import { useAuthActions } from "./AuthProvider.js";
+const useWalletDisplayHelpers = (wallet) => {
+  const isUsingMobileConnector = useModalStore((state) => state.isUsingMobileConnector);
+  return {
+    // Show the extension screen if on web and the wallet is an extension and installed or the wallet isn't a mobile wallet
+    // Also show the extension connection if on desktop for a solana wallet (no walletConnect)
+    showExtension: !isMobile() && ((wallet == null ? void 0 : wallet.isExtension) && (wallet == null ? void 0 : wallet.installed) || !(wallet == null ? void 0 : wallet.isMobile) || (wallet == null ? void 0 : wallet.type) === "SOLANA"),
+    // Show the mobile screen if on mobile and the wallet is a mobile wallet or if on desktop and the wallet isn't installed
+    showMobile: isMobile() && (wallet == null ? void 0 : wallet.isMobile) || !isMobile() && !(wallet == null ? void 0 : wallet.installed),
+    isCosmosMobileWallet: (wallet == null ? void 0 : wallet.type) === "COSMOS" && !!isUsingMobileConnector
+  };
+};
+const defaultExternalWallet = {
+  wallets: [],
+  chains: [],
+  chainId: void 0,
+  wallet: void 0,
+  qrUri: void 0,
+  chainIdSwitchingTo: void 0,
+  walletDisplayHelpers: { showExtension: false, showMobile: false, isCosmosMobileWallet: false },
+  username: void 0,
+  avatar: void 0,
+  connectExternalWallet: () => Promise.resolve(),
+  disconnectExternalWallet: () => Promise.resolve(),
+  switchChain: () => Promise.resolve(),
+  setChainIdSwitchingTo: () => {
+  },
+  connectEmbeddedToExternalConnectors: () => Promise.resolve(),
+  verifyWalletSignature: () => Promise.resolve({}),
+  signMessage: () => Promise.resolve({}),
+  isSigningMessage: false,
+  getWalletBalance: () => Promise.resolve(void 0),
+  requestInfo: (_) => Promise.resolve({}),
+  disconnectBase: (_) => Promise.resolve()
+};
+const ExternalWalletContext = createContext(defaultExternalWallet);
+function ExternalWalletProvider({ children }) {
+  const evmContext = useStore((state) => state.evmContext);
+  const cosmosContext = useStore((state) => state.cosmosContext);
+  const solanaContext = useStore((state) => state.solanaContext);
+  const externalWallets = useStore((state) => state.externalWallets);
+  const externalWalletsWithFullAuth = useStore((state) => state.externalWalletsWithFullAuth);
+  const includeWalletVerification = useStore((state) => state.includeWalletVerification);
+  const connectionOnly = useStore((state) => state.connectionOnly);
+  const {
+    wallets: evmWallets,
+    disconnect: evmDisconnect,
+    chains: evmChains,
+    chainId: evmChainId,
+    switchChain: evmSwitchChain,
+    username: evmUsername,
+    avatar: evmAvatar,
+    connectParaEmbedded: evmConnectParaEmbedded,
+    signMessage: evmSignMessage,
+    signVerificationMessage: evmSignVerificationMessage,
+    getWalletBalance: evmGetWalletBalance,
+    requestInfo: evmRequestInfo,
+    disconnectBase: evmDisconnectBase,
+    farcasterStatus: evmFarcasterStatus
+  } = useContext(evmContext);
+  const {
+    wallets: solanaWallets,
+    disconnect: solanaDisconnect,
+    signMessage: solanaSignMessage,
+    signVerificationMessage: solanaSignVerificationMessage,
+    requestInfo: solanaRequestInfo,
+    disconnectBase: solanaDisconnectBase
+  } = useContext(solanaContext);
+  const {
+    wallets: cosmosWallets,
+    disconnect: cosmosDisconnect,
+    chains: cosmosChains,
+    chainId: cosmosChainId,
+    switchChain: cosmosSwitchChain,
+    connectParaEmbedded: cosmosConnectParaEmbedded,
+    signMessage: cosmosSignMessage,
+    signVerificationMessage: cosmosSignVerificationMessage,
+    requestInfo: cosmosRequestInfo,
+    disconnectBase: cosmosDisconnectBase
+  } = useContext(cosmosContext);
+  const onLoginRef = useStore((state) => state.onLoginRef);
+  const setStep = useModalStore((state) => state.setStep);
+  const setStepDirection = useModalStore((state) => state.setStepDirection);
+  const setIsExternalWalletConnecting = useModalStore((state) => state.setIsExternalWalletConnecting);
+  const isExternalWalletConnecting = useModalStore((state) => state.isExternalWalletConnecting);
+  const setSelectedExternalWalletId = useModalStore((state) => state.setSelectedExternalWalletId);
+  const selectedExternalWalletId = useModalStore((state) => state.selectedExternalWalletId);
+  const setExternalWalletError = useModalStore((state) => state.setExternalWalletError);
+  const setIsUsingMobileConnector = useModalStore((state) => state.setIsUsingMobileConnector);
+  const para = useInternalClient();
+  const { setSelectedWallet } = useWalletState();
+  const { onNewAuthState } = useAuthActions();
+  const { mutateAsync: verifyExternalWallet } = useVerifyExternalWallet();
+  const [qrUri, setQrUri] = useState();
+  const [chainIdSwitchingTo, setChainIdSwitchingTo] = useState();
+  const [isSigningMessage, setIsSigningMessage] = useState(false);
+  const wallets = [...evmWallets, ...solanaWallets, ...cosmosWallets].filter(
+    (w) => (w.internalId !== "FARCASTER" || (para == null ? void 0 : para.isFarcasterMiniApp)) && externalWallets.includes(w.id.toUpperCase())
+  ).sort(
+    (a, b) => externalWallets.indexOf(a.id.toUpperCase()) - externalWallets.indexOf(b.id.toUpperCase())
+  ).sort((a, b) => a.installed === b.installed ? 0 : a.installed ? -1 : 1);
+  const wallet = useMemo(
+    () => wallets.find((w) => w.internalId === selectedExternalWalletId),
+    [wallets, selectedExternalWalletId]
+  );
+  const updateQrUri = () => __async(this, null, function* () {
+    var _a;
+    const uri = yield (_a = wallet == null ? void 0 : wallet.getQrUri) == null ? void 0 : _a.call(wallet);
+    setQrUri(uri);
+  });
+  useEffect(() => {
+    if (wallet) {
+      if (!qrUri) {
+        updateQrUri();
+      }
+    } else if (qrUri) {
+      setQrUri(void 0);
+    }
+  }, [wallet]);
+  const getWalletBalance = useCallback(() => __async(this, null, function* () {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    switch (walletType) {
+      case "EVM": {
+        return yield evmGetWalletBalance();
+      }
+      default: {
+        return void 0;
+      }
+    }
+  }), [evmGetWalletBalance, selectedExternalWalletId]);
+  const chains = useMemo(() => {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    switch (walletType) {
+      case "COSMOS": {
+        return cosmosChains;
+      }
+      case "EVM": {
+        return evmChains;
+      }
+      default: {
+        return [];
+      }
+    }
+  }, [cosmosChains, evmChains, selectedExternalWalletId]);
+  const chainId = useMemo(() => {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    switch (walletType) {
+      case "COSMOS": {
+        return cosmosChainId;
+      }
+      case "EVM": {
+        return evmChainId == null ? void 0 : evmChainId.toString();
+      }
+      default: {
+        return void 0;
+      }
+    }
+  }, [cosmosChains, evmChains, selectedExternalWalletId]);
+  const switchChain = useCallback(
+    (chainId2) => __async(this, null, function* () {
+      var _a;
+      const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+      if (walletType) {
+        let resp;
+        setExternalWalletError();
+        setChainIdSwitchingTo(chainId2);
+        switch (walletType) {
+          case "COSMOS": {
+            setStep(ModalStep.CHAIN_SWITCH);
+            resp = yield cosmosSwitchChain(chainId2);
+            break;
+          }
+          case "EVM": {
+            setStep(ModalStep.CHAIN_SWITCH);
+            resp = yield evmSwitchChain(parseInt(chainId2));
+            break;
+          }
+          default: {
+            resp = {};
+            break;
+          }
+        }
+        if (resp.error) {
+          setExternalWalletError(resp.error);
+        } else {
+          setChainIdSwitchingTo(void 0);
+          setStepDirection(-1);
+          setStep(ModalStep.ACCOUNT_MAIN);
+        }
+      }
+    }),
+    [evmSwitchChain, cosmosSwitchChain]
+  );
+  const verifyWalletSignature = useCallback(() => __async(this, null, function* () {
+    var _a;
+    setExternalWalletError();
+    const wallet2 = Object.values(para.externalWallets)[0];
+    const walletType = wallet2 == null ? void 0 : wallet2.type;
+    let verifyExternalWalletParams;
+    const withVerification = includeWalletVerification;
+    const isConnectionOnly = connectionOnly;
+    const withFullParaAuth = (wallet2 == null ? void 0 : wallet2.name) ? externalWalletsWithFullAuth.includes(wallet2.name.toUpperCase()) : false;
+    const defaultWalletInfo = {
+      withVerification,
+      isConnectionOnly,
+      withFullParaAuth,
+      provider: wallet2.name,
+      providerId: wallet2.externalProviderId,
+      isExternal: true
+    };
+    switch (walletType) {
+      case "COSMOS":
+        {
+          const { address, signature, error, cosmosPublicKeyHex, cosmosSigner, addressBech32 } = yield cosmosSignVerificationMessage();
+          if (error) {
+            setExternalWalletError([error]);
+          } else if (signature && address) {
+            verifyExternalWalletParams = {
+              externalWallet: __spreadValues({
+                type: "COSMOS",
+                address,
+                addressBech32
+              }, defaultWalletInfo),
+              signedMessage: signature,
+              cosmosPublicKeyHex,
+              cosmosSigner
+            };
+          }
+        }
+        break;
+      case "EVM":
+        {
+          const { signature, error, address } = yield evmSignVerificationMessage();
+          if (error) {
+            setExternalWalletError([error]);
+          } else if (signature && address) {
+            verifyExternalWalletParams = {
+              externalWallet: __spreadValues({
+                type: "EVM",
+                address
+              }, defaultWalletInfo),
+              signedMessage: signature
+            };
+          }
+        }
+        break;
+      case "SOLANA":
+        {
+          const { signature, error, address } = yield solanaSignVerificationMessage();
+          if (error) {
+            setExternalWalletError([error]);
+          } else if (signature && address) {
+            verifyExternalWalletParams = {
+              externalWallet: __spreadValues({
+                type: "SOLANA",
+                address
+              }, defaultWalletInfo),
+              signedMessage: signature
+            };
+          }
+        }
+        break;
+      default:
+        break;
+    }
+    if (!(verifyExternalWalletParams == null ? void 0 : verifyExternalWalletParams.externalWallet) || !(verifyExternalWalletParams == null ? void 0 : verifyExternalWalletParams.signedMessage)) {
+      console.error("No signature or address found on the verifyWalletSignature response.");
+      setExternalWalletError(["Signature verification failed."]);
+      return;
+    }
+    try {
+      const d = yield verifyExternalWallet(verifyExternalWalletParams);
+      if (wallet2 && (externalWalletsWithFullAuth == null ? void 0 : externalWalletsWithFullAuth.includes((_a = wallet2.name) == null ? void 0 : _a.toUpperCase()))) {
+        yield onNewAuthState(d);
+      } else {
+        setStep(ModalStep.LOGIN_DONE);
+      }
+    } catch (e) {
+      console.error("Error verifying signature:", e);
+      setExternalWalletError(["Signature verification failed."]);
+    }
+    return verifyExternalWalletParams;
+  }), [cosmosSignVerificationMessage, evmSignVerificationMessage, solanaSignVerificationMessage, wallet]);
+  const signMessage = useCallback(
+    (_0) => __async(this, [_0], function* ({ message, externalWallet: _externalWallet }) {
+      var _a;
+      setExternalWalletError();
+      setIsSigningMessage(true);
+      let externalWallet = _externalWallet;
+      const walletType = (externalWallet == null ? void 0 : externalWallet.type) || ((_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type);
+      let response;
+      try {
+        switch (walletType) {
+          case "COSMOS":
+            {
+              const { address, signature, error, cosmosPublicKeyHex, cosmosSigner } = yield cosmosSignMessage({
+                message,
+                externalWallet
+              });
+              if (error) {
+                throw new Error(error);
+              } else if (signature && address) {
+                response = { address, signature, cosmosPublicKeyHex, cosmosSigner };
+              }
+            }
+            break;
+          case "EVM":
+            {
+              const { address, signature, error } = yield evmSignMessage({ message, externalWallet });
+              if (error) {
+                throw new Error(error);
+              } else if (signature && address) {
+                response = { address, signature };
+              }
+            }
+            break;
+          case "SOLANA":
+            {
+              const { signature, error, address } = yield solanaSignMessage({ message });
+              if (error) {
+                throw new Error(error);
+              } else if (signature && address) {
+                response = { address, signature };
+              }
+            }
+            break;
+          default:
+            break;
+        }
+        setIsSigningMessage(false);
+        return response;
+      } catch (error) {
+        setIsSigningMessage(false);
+        throw error;
+      }
+    }),
+    [cosmosSignMessage, evmSignMessage, solanaSignMessage]
+  );
+  const connectExternalWallet = useCallback(
+    (wallet2, isMobileConnect, isManualWalletConnect, isResetAfterManualWalletConnect) => __async(this, null, function* () {
+      if (isExternalWalletConnecting && isManualWalletConnect) {
+        yield evmDisconnect();
+        yield solanaDisconnect();
+        yield cosmosDisconnect();
+        setQrUri(void 0);
+        setIsExternalWalletConnecting(false);
+      }
+      if (isResetAfterManualWalletConnect || isManualWalletConnect || !isExternalWalletConnecting) {
+        setExternalWalletError();
+        setIsExternalWalletConnecting(true);
+        setIsUsingMobileConnector(isMobileConnect);
+        const { address, error, authState } = yield isMobileConnect ? wallet2.connectMobile(isManualWalletConnect, connectionOnly) : wallet2.connect(connectionOnly);
+        if (error) {
+          setExternalWalletError([error]);
+          setIsUsingMobileConnector();
+          if (isManualWalletConnect && error === "Connection request rejected") {
+            setExternalWalletError();
+            yield connectExternalWallet(wallet2, false, false, true);
+            yield updateQrUri();
+            return;
+          }
+        } else if (address) {
+          if (!!authState && ((externalWalletsWithFullAuth == null ? void 0 : externalWalletsWithFullAuth.includes(wallet2.name.toUpperCase())) || includeWalletVerification)) {
+            onNewAuthState(authState);
+          } else {
+            setStep(ModalStep.LOGIN_DONE);
+          }
+        }
+        setIsExternalWalletConnecting(false);
+      }
+    }),
+    [isExternalWalletConnecting, externalWalletsWithFullAuth, connectionOnly, includeWalletVerification]
+  );
+  const requestInfo = (providerId, type) => __async(this, null, function* () {
+    switch (type) {
+      case "EVM": {
+        const externalWallet = yield evmRequestInfo(providerId);
+        return externalWallet;
+      }
+      case "SOLANA": {
+        const externalWallet = yield solanaRequestInfo(providerId);
+        return externalWallet;
+      }
+      case "COSMOS": {
+        const externalWallet = yield cosmosRequestInfo(providerId);
+        return externalWallet;
+      }
+    }
+  });
+  const disconnectBase = (providerId) => __async(this, null, function* () {
+    const [isEvm, isSolana, _isCosmos] = [
+      EVM_WALLETS.includes(providerId),
+      SOLANA_WALLETS.includes(providerId),
+      COSMOS_WALLETS.includes(providerId)
+    ];
+    switch (true) {
+      case isEvm:
+        yield evmDisconnectBase(providerId);
+        break;
+      case isSolana:
+        yield solanaDisconnectBase(providerId);
+        break;
+      default: {
+        yield cosmosDisconnectBase();
+        break;
+      }
+    }
+  });
+  const disconnectExternalWallet = () => __async(this, null, function* () {
+    yield para.logout();
+    yield evmDisconnect();
+    yield cosmosDisconnect();
+    setSelectedExternalWalletId();
+    yield solanaDisconnect();
+  });
+  const walletDisplayHelpers = useWalletDisplayHelpers(wallet);
+  const username = useMemo(() => {
+    let username2;
+    const storedExternalWallet = Object.values(para.externalWallets || {})[0];
+    if (storedExternalWallet) {
+      const walletType = storedExternalWallet == null ? void 0 : storedExternalWallet.type;
+      switch (walletType) {
+        case "EVM": {
+          username2 = evmUsername ? evmUsername.startsWith("0x") ? truncateAddress(evmUsername, "EVM") : evmUsername : void 0;
+          break;
+        }
+        default: {
+          username2 = storedExternalWallet.address && storedExternalWallet.type ? truncateAddress(storedExternalWallet.address, storedExternalWallet.type) : void 0;
+          break;
+        }
+      }
+    }
+    return username2;
+  }, [evmUsername, wallet]);
+  const avatar = useMemo(() => {
+    var _a;
+    const walletType = (_a = Object.values(para.externalWallets || {})[0]) == null ? void 0 : _a.type;
+    if (walletType) {
+      switch (walletType) {
+        case "EVM": {
+          return evmAvatar;
+        }
+        default: {
+          return void 0;
+        }
+      }
+    }
+  }, [evmAvatar, wallet]);
+  const connectEmbeddedToExternalConnectors = useCallback(() => __async(this, null, function* () {
+    const evmWallet = para.findWallet(void 0, void 0, { type: ["EVM"] });
+    const cosmosWallet = para.findWallet(void 0, void 0, { type: ["COSMOS"] });
+    if (evmWallet) {
+      try {
+        const { error } = yield evmConnectParaEmbedded();
+        if (error) {
+          console.warn("Failed to connect Para EVM wallet to Wagmi:", error);
+        } else {
+          if (evmWallet) {
+            setSelectedWallet({ id: evmWallet.id, type: "EVM" });
+          }
+        }
+      } catch (err) {
+        console.warn("Error calling connectParaEvmWallet:", err);
+      }
+    }
+    if (cosmosWallet) {
+      try {
+        const { error } = yield cosmosConnectParaEmbedded();
+        if (error) {
+          console.warn("Failed to connect Para Cosmos wallet to Graz:", error);
+        } else {
+          if (cosmosWallet) {
+            setSelectedWallet({ id: cosmosWallet.id, type: "COSMOS" });
+          }
+        }
+      } catch (err) {
+        console.warn("Error calling connectParaCosmosWallet:", err);
+      }
+    }
+  }), [evmConnectParaEmbedded, cosmosConnectParaEmbedded]);
+  useEffect(() => {
+    onLoginRef.current = () => __async(this, null, function* () {
+      yield connectEmbeddedToExternalConnectors();
+    });
+  }, [connectEmbeddedToExternalConnectors]);
+  useEffect(() => {
+    function loginFarcasterMiniApp() {
+      return __async(this, null, function* () {
+        if (para.isReady && para.isFarcasterMiniApp) {
+          const isEvm = para.supportedWalletTypes.some(({ type }) => type === "EVM");
+          const isAwaitingEvmLogin = isEvm && (evmFarcasterStatus == null ? void 0 : evmFarcasterStatus.isConnected) && !Object.values(para.externalWallets || {}).some(
+            (w) => w.type === "EVM" && w.externalProviderId === "FARCASTER" && w.address === evmFarcasterStatus.address
+          );
+          const isAwaitingLogin = isAwaitingEvmLogin;
+          if (isAwaitingLogin) {
+            yield para.loginExternalWallet({
+              externalWallet: [
+                ...isAwaitingEvmLogin ? [
+                  {
+                    type: "EVM",
+                    provider: "Farcaster",
+                    providerId: "FARCASTER",
+                    address: evmFarcasterStatus.address,
+                    isConnectionOnly: true
+                  }
+                ] : []
+              ]
+            });
+          }
+        }
+      });
+    }
+    loginFarcasterMiniApp();
+  }, [para.isReady, para.isFarcasterMiniApp, evmFarcasterStatus]);
+  return /* @__PURE__ */ jsx(
+    ExternalWalletContext.Provider,
+    {
+      value: useMemo(
+        () => ({
+          wallets,
+          chains,
+          chainId,
+          wallet,
+          qrUri,
+          walletDisplayHelpers,
+          chainIdSwitchingTo,
+          username,
+          avatar,
+          connectExternalWallet,
+          disconnectExternalWallet,
+          switchChain,
+          setChainIdSwitchingTo,
+          connectEmbeddedToExternalConnectors,
+          signMessage,
+          isSigningMessage,
+          verifyWalletSignature,
+          getWalletBalance,
+          requestInfo,
+          disconnectBase
+        }),
+        [
+          wallets,
+          chains,
+          chainId,
+          wallet,
+          qrUri,
+          walletDisplayHelpers,
+          chainIdSwitchingTo,
+          username,
+          avatar,
+          disconnectExternalWallet,
+          connectExternalWallet,
+          switchChain,
+          setChainIdSwitchingTo,
+          connectEmbeddedToExternalConnectors,
+          signMessage,
+          isSigningMessage,
+          verifyWalletSignature,
+          getWalletBalance,
+          requestInfo,
+          disconnectBase
+        ]
+      ),
+      children
+    }
+  );
+}
+const useExternalWallets = () => useContext(ExternalWalletContext);
+export {
+  ExternalWalletContext,
+  ExternalWalletProvider,
+  defaultExternalWallet,
+  useExternalWallets,
+  useWalletDisplayHelpers
+};