@getpara/react-sdk 0.1.0

package/dist/modal/constants/oAuthLogos.js

@@ -0,0 +1,18 @@
+export const brandedOAuthLogos = {
+    GOOGLE: 'googleBrand',
+    TWITTER: 'twitter',
+    APPLE: 'apple',
+    DISCORD: 'discordBrand',
+    FACEBOOK: 'facebookBrand',
+    FARCASTER: 'farcasterBrand',
+    TELEGRAM: 'telegramBrand',
+};
+export const oAuthLogos = {
+    GOOGLE: 'google',
+    TWITTER: 'twitter',
+    APPLE: 'apple',
+    DISCORD: 'discord',
+    FACEBOOK: 'facebook',
+    FARCASTER: 'farcaster',
+    TELEGRAM: 'telegram',
+};

package/dist/modal/css/modal.css

@@ -0,0 +1,13 @@
+@import url('@getpara/react-components/css/capsule-core.css');
+
+@font-face {
+  font-family: 'Inter';
+  src: url('../public/Inter-VariableFont_slnt,wght.ttf') format('truetype');
+}
+
+html {
+  --cpsl-default-font: 'Inter', sans-serif;
+  -webkit-overflow-scrolling: touch;
+
+  --wcm-z-index: 11000 !important;
+}

package/dist/modal/hooks/useActiveWallet.d.ts

@@ -0,0 +1 @@
+export declare function useActiveWallet(): Omit<import("@getpara/core-sdk").Wallet, "signer">;

package/dist/modal/hooks/useActiveWallet.js

@@ -0,0 +1,9 @@
+import { useMemo } from 'react';
+import { useParaStore, useModalStore } from '../stores/index.js';
+export function useActiveWallet() {
+    const para = useParaStore(state => state.para);
+    const [activeWalletId, activeWalletType] = useModalStore(state => state.activeWallet);
+    return useMemo(() => {
+        return para.findWallet(activeWalletId, activeWalletType, { forbidPregen: true });
+    }, [para, activeWalletId, activeWalletType]);
+}

package/dist/modal/hooks/useEmbeddedExternalConnection.d.ts

@@ -0,0 +1 @@
+export declare const useEmbeddedExternalConnection: () => () => Promise<void>;

package/dist/modal/hooks/useEmbeddedExternalConnection.js

@@ -0,0 +1,46 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useExternalWalletProviderStore } from '../stores/externalWalletProvider/useExternalWalletProviderStore.js';
+export const useEmbeddedExternalConnection = () => {
+    // Get the connectParaEvmWallet action if available. This is used to trigger Para as an active connection when the user logs in using a non external wallet method.
+    const connectParaEvmWallet = useExternalWalletProviderStore(state => state.connectParaEvmWallet);
+    const EvmProvider = useExternalWalletProviderStore(state => state.EvmProvider);
+    const evmContext = useExternalWalletProviderStore(state => state.evmContext);
+    const connectParaCosmosWallet = useExternalWalletProviderStore(state => state.connectParaCosmosWallet);
+    const CosmosProvider = useExternalWalletProviderStore(state => state.CosmosProvider);
+    const cosmosContext = useExternalWalletProviderStore(state => state.cosmosContext);
+    const connectEmbeddedToExternalConnectors = () => __awaiter(void 0, void 0, void 0, function* () {
+        // If we're in the ParaEvmProvider context call the connect method to trigger Para as an active connection
+        if (evmContext && EvmProvider && connectParaEvmWallet) {
+            try {
+                const { error } = yield connectParaEvmWallet();
+                if (error) {
+                    console.warn('Failed to connect Para EVM wallet to Wagmi:', error);
+                }
+            }
+            catch (err) {
+                console.warn('Error calling connectParaEvmWallet:', err);
+            }
+        }
+        // If we're in the ParaCosmosProvider context call the connect method to trigger Para as an active connection
+        if (cosmosContext && CosmosProvider && connectParaCosmosWallet) {
+            try {
+                const { error } = yield connectParaCosmosWallet();
+                if (error) {
+                    console.warn('Failed to connect Para Cosmos wallet to Graz:', error);
+                }
+            }
+            catch (err) {
+                console.warn('Error calling connectParaCosmosWallet:', err);
+            }
+        }
+    });
+    return connectEmbeddedToExternalConnectors;
+};

package/dist/modal/hooks/useGoBack.d.ts

@@ -0,0 +1 @@
+export declare const useGoBack: () => () => void;

package/dist/modal/hooks/useGoBack.js

@@ -0,0 +1,34 @@
+import { useExternalWallets } from '../providers/ExternalWalletContext.js';
+import { useModalStore } from '../stores/index.js';
+import { getAddFundsStep, ModalStep } from '../utils/steps.js';
+export const useGoBack = () => {
+    const currentStep = useModalStore(state => state.step);
+    const setStep = useModalStore(state => state.setStep);
+    const accountAddFundTab = useModalStore(state => state.accountAddFundTab);
+    const decrementStep = useModalStore(state => state.decrementStep);
+    const resetState = useModalStore(state => state.resetState);
+    const { setChainIdSwitchingTo } = useExternalWallets();
+    const goBack = () => {
+        if (currentStep === ModalStep.ADD_FUNDS_AWAITING) {
+            setStep(getAddFundsStep(accountAddFundTab));
+        }
+        else {
+            decrementStep();
+        }
+        switch (currentStep) {
+            case ModalStep.VERIFY_2FA:
+            case ModalStep.BIOMETRIC_CREATION:
+            case ModalStep.BIOMETRIC_LOGIN: {
+                resetState();
+                break;
+            }
+        }
+        switch (currentStep) {
+            case ModalStep.CHAIN_SWITCH: {
+                setChainIdSwitchingTo();
+                break;
+            }
+        }
+    };
+    return goBack;
+};

package/dist/modal/index.d.ts

@@ -0,0 +1,10 @@
+export * from './ParaModal.js';
+export type { ParaModalProps, ParaModalHandle, ParaModalTheme } from './types/modalProps.js';
+export { ModalStep, type ModalStepProp } from './utils/steps.js';
+export { AuthLayout } from './types/modalProps.js';
+export * from './utils/openPopup.js';
+export { ON_RAMP_PROVIDERS, ON_RAMP_ASSETS, NETWORKS, getAssetIcon, getAssetName, getNetworkIcon, getNetworkName, } from './constants/constants.js';
+export { SaveRecoverySecret } from './components/RecoverySecretStep/RecoverySecretStep.js';
+export * from './utils/validateOnRampConfig.js';
+export * from './types/externalWallets.js';
+export { useExternalWalletProviderStore } from './stores/externalWalletProvider/useExternalWalletProviderStore.js';

package/dist/modal/index.js

@@ -0,0 +1,9 @@
+export * from './ParaModal.js';
+export { ModalStep } from './utils/steps.js';
+export { AuthLayout } from './types/modalProps.js';
+export * from './utils/openPopup.js';
+export { ON_RAMP_PROVIDERS, ON_RAMP_ASSETS, NETWORKS, getAssetIcon, getAssetName, getNetworkIcon, getNetworkName, } from './constants/constants.js';
+export { SaveRecoverySecret } from './components/RecoverySecretStep/RecoverySecretStep.js';
+export * from './utils/validateOnRampConfig.js';
+export * from './types/externalWallets.js';
+export { useExternalWalletProviderStore } from './stores/externalWalletProvider/useExternalWalletProviderStore.js';

package/dist/modal/providers/CosmosExternalWalletContextStub.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+import { CommonChain, CommonWallet } from '../types/commonTypes.js';
+import ParaWeb from '@getpara/web-sdk';
+export declare const defaultCosmosExternalWallet: {
+    wallets: any[];
+    chains: any[];
+    chainId: any;
+    disconnect: () => Promise<void>;
+    switchChain: () => Promise<{}>;
+};
+export type CosmosExternalWalletContextType = {
+    wallets: CommonWallet[];
+    chains: CommonChain[];
+    chainId: string;
+    disconnect: () => Promise<void>;
+    switchChain: (chainId: string) => Promise<{
+        error?: string[];
+    }>;
+};
+export declare const CosmosExternalWalletContext: import("react").Context<CosmosExternalWalletContextType>;
+export interface CosmosExternalWalletProviderProps {
+    children: ReactNode;
+    para: ParaWeb;
+    onSwitchWallet: (args: {
+        address?: string;
+        error?: string;
+    }) => void;
+}
+export declare function CosmosExternalWalletProvider({ children }: CosmosExternalWalletProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/modal/providers/CosmosExternalWalletContextStub.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useMemo } from 'react';
+export const defaultCosmosExternalWallet = {
+    wallets: [],
+    chains: [],
+    chainId: undefined,
+    disconnect: () => Promise.resolve(),
+    switchChain: () => Promise.resolve({}),
+};
+export const CosmosExternalWalletContext = createContext(defaultCosmosExternalWallet);
+export function CosmosExternalWalletProvider({ children }) {
+    const wallets = [];
+    const chains = [];
+    const chainId = undefined;
+    const disconnect = () => Promise.resolve();
+    const switchChain = () => Promise.resolve({});
+    return (_jsx(CosmosExternalWalletContext.Provider, { value: useMemo(() => ({ wallets, chains, chainId, disconnect, switchChain }), [wallets, chains, chainId, disconnect, switchChain]), children: children }));
+}

package/dist/modal/providers/EvmExternalWalletContextStub.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+import { CommonChain, CommonWallet } from '../types/commonTypes.js';
+import ParaWeb from '@getpara/web-sdk';
+export declare const defaultEvmExternalWallet: {
+    wallets: any[];
+    chains: any[];
+    chainId: any;
+    username: any;
+    avatar: any;
+    disconnect: () => Promise<void>;
+    switchChain: () => Promise<{}>;
+};
+export type EvmExternalWalletContextType = {
+    wallets: CommonWallet[];
+    chains: CommonChain[];
+    chainId: number;
+    username: string;
+    avatar?: string;
+    disconnect: () => Promise<void>;
+    switchChain: (chainId: number) => Promise<{
+        error?: string[];
+    }>;
+};
+export declare const EvmExternalWalletContext: import("react").Context<EvmExternalWalletContextType>;
+export interface EvmExternalWalletProviderProps {
+    children: ReactNode;
+    para: ParaWeb;
+    onSwitchWallet: (args: {
+        address?: string;
+        error?: string;
+    }) => void;
+}
+export declare function EvmExternalWalletProvider({ children }: EvmExternalWalletProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/modal/providers/EvmExternalWalletContextStub.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useMemo } from 'react';
+export const defaultEvmExternalWallet = {
+    wallets: [],
+    chains: [],
+    chainId: undefined,
+    username: undefined,
+    avatar: undefined,
+    disconnect: () => Promise.resolve(),
+    switchChain: () => Promise.resolve({}),
+};
+export const EvmExternalWalletContext = createContext(defaultEvmExternalWallet);
+export function EvmExternalWalletProvider({ children }) {
+    const wallets = [];
+    const chains = [];
+    const chainId = undefined;
+    const username = undefined;
+    const avatar = undefined;
+    const disconnect = () => Promise.resolve();
+    const switchChain = () => Promise.resolve({});
+    return (_jsx(EvmExternalWalletContext.Provider, { value: useMemo(() => ({ wallets, chains, chainId, username, avatar, disconnect, switchChain }), [wallets, chains, chainId, username, avatar, disconnect, switchChain]), children: children }));
+}

package/dist/modal/providers/ExternalWalletContext.d.ts

@@ -0,0 +1,75 @@
+import { Context, ReactNode } from 'react';
+import { CommonChain, CommonWallet } from '../types/commonTypes.js';
+import { EvmExternalWalletContextType } from './EvmExternalWalletContextStub.js';
+import { TExternalWallet } from '../types/externalWallets.js';
+import { SolanaExternalWalletContextType } from './SolanaExternalWalletContextStub.js';
+import { CosmosExternalWalletContextType } from './CosmosExternalWalletContextStub.js';
+export declare const defaultExternalWallet: {
+    wallets: any[];
+    chains: any[];
+    chainId: any;
+    wallet: any;
+    qrUri: any;
+    chainIdSwitchingTo: any;
+    walletDisplayHelpers: {
+        showExtension: boolean;
+        showMobile: boolean;
+        isSolanaMobileIOS: boolean;
+        isCosmosMobileWallet: boolean;
+    };
+    username: any;
+    avatar: any;
+    connectExternalWallet: () => void;
+    disconnectExternalWallet: () => Promise<void>;
+    switchChain: () => Promise<void>;
+    setChainIdSwitchingTo: () => void;
+};
+export declare const ExternalWalletContext: Context<{
+    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) => void;
+    disconnectExternalWallet: () => Promise<void>;
+    switchChain: (chainId: string) => Promise<void>;
+    setChainIdSwitchingTo: (chainId?: string) => void;
+}>;
+interface ExternalWalletProviderProps {
+    children: ReactNode;
+    walletSort: TExternalWallet[];
+    evmContext: Context<EvmExternalWalletContextType>;
+    solanaContext: Context<SolanaExternalWalletContextType>;
+    cosmosContext: Context<CosmosExternalWalletContextType>;
+}
+export declare function ExternalWalletProvider({ children, evmContext, solanaContext, cosmosContext, walletSort, }: ExternalWalletProviderProps): 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) => void;
+    disconnectExternalWallet: () => Promise<void>;
+    switchChain: (chainId: string) => Promise<void>;
+    setChainIdSwitchingTo: (chainId?: string) => void;
+};
+export {};

package/dist/modal/providers/ExternalWalletContext.js

@@ -0,0 +1,252 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import { useParaStore, useModalStore } from '../stores/index.js';
+import { ModalStep } from '../utils/steps.js';
+import { WalletType, isIOS, isIOSWebview, isMobile, truncateAddress } from '@getpara/web-sdk';
+export const defaultExternalWallet = {
+    wallets: [],
+    chains: [],
+    chainId: undefined,
+    wallet: undefined,
+    qrUri: undefined,
+    chainIdSwitchingTo: undefined,
+    walletDisplayHelpers: {
+        showExtension: false,
+        showMobile: false,
+        isSolanaMobileIOS: false,
+        isCosmosMobileWallet: false,
+    },
+    username: undefined,
+    avatar: undefined,
+    connectExternalWallet: () => { },
+    disconnectExternalWallet: () => Promise.resolve(),
+    switchChain: () => Promise.resolve(),
+    setChainIdSwitchingTo: () => { },
+};
+export const ExternalWalletContext = createContext(defaultExternalWallet);
+export function ExternalWalletProvider({ children, evmContext, solanaContext, cosmosContext, walletSort, }) {
+    const { wallets: evmWallets, disconnect: evmDisconnect, chains: evmChains, chainId: evmChainId, switchChain: evmSwitchChain, username: evmUsername, avatar: evmAvatar, } = useContext(evmContext);
+    const { wallets: solanaWallets, disconnect: solanaDisconnect } = useContext(solanaContext);
+    const { wallets: cosmosWallets, disconnect: cosmosDisconnect, chains: cosmosChains, chainId: cosmosChainId, switchChain: cosmosSwitchChain, } = useContext(cosmosContext);
+    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 isUsingMobileConnector = useModalStore(state => state.isUsingMobileConnector);
+    const para = useParaStore(state => state.para);
+    const [qrUri, setQrUri] = useState();
+    const [chainIdSwitchingTo, setChainIdSwitchingTo] = useState();
+    // Filter any wallets that aren't included in the sort array, sort by the array then sort by installed extensions
+    const wallets = [...evmWallets, ...solanaWallets, ...cosmosWallets]
+        .filter(w => walletSort.includes(w.id.toUpperCase()))
+        .sort((a, b) => walletSort.indexOf(a.id.toUpperCase()) -
+        walletSort.indexOf(b.id.toUpperCase()))
+        .sort((a, b) => (a.installed === b.installed ? 0 : a.installed ? -1 : 1));
+    const wallet = useMemo(() => wallets.find(w => w.id === selectedExternalWalletId), [wallets, selectedExternalWalletId]);
+    const updateQrUri = () => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const uri = yield ((_a = wallet === null || wallet === void 0 ? void 0 : wallet.getQrUri) === null || _a === void 0 ? void 0 : _a.call(wallet));
+        setQrUri(uri);
+    });
+    useEffect(() => {
+        if (wallet) {
+            if (!qrUri) {
+                updateQrUri();
+            }
+        }
+        else if (qrUri) {
+            setQrUri(undefined);
+        }
+    }, [wallet]);
+    const chains = useMemo(() => {
+        var _a, _b, _c;
+        const walletType = (_c = para.externalWallets[(_b = (_a = para.currentExternalWalletAddresses) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : '']) === null || _c === void 0 ? void 0 : _c.type;
+        switch (walletType) {
+            case WalletType.COSMOS: {
+                return cosmosChains;
+            }
+            case WalletType.EVM: {
+                return evmChains;
+            }
+            default: {
+                return [];
+            }
+        }
+    }, [cosmosChains, evmChains, selectedExternalWalletId]);
+    const chainId = useMemo(() => {
+        var _a, _b, _c;
+        const walletType = (_c = para.externalWallets[(_b = (_a = para.currentExternalWalletAddresses) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : '']) === null || _c === void 0 ? void 0 : _c.type;
+        switch (walletType) {
+            case WalletType.COSMOS: {
+                return cosmosChainId;
+            }
+            case WalletType.EVM: {
+                return evmChainId === null || evmChainId === void 0 ? void 0 : evmChainId.toString();
+            }
+            default: {
+                return undefined;
+            }
+        }
+    }, [cosmosChains, evmChains, selectedExternalWalletId]);
+    const switchChain = useCallback((chainId) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const walletType = (_c = para.externalWallets[(_b = (_a = para.currentExternalWalletAddresses) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : '']) === null || _c === void 0 ? void 0 : _c.type;
+        if (walletType) {
+            let resp;
+            setExternalWalletError();
+            setChainIdSwitchingTo(chainId);
+            switch (walletType) {
+                case WalletType.COSMOS: {
+                    setStep(ModalStep.CHAIN_SWITCH);
+                    resp = yield cosmosSwitchChain(chainId);
+                    break;
+                }
+                case WalletType.EVM: {
+                    setStep(ModalStep.CHAIN_SWITCH);
+                    resp = yield evmSwitchChain(parseInt(chainId));
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+            if (resp.error) {
+                setExternalWalletError(resp.error);
+            }
+            else {
+                setChainIdSwitchingTo(undefined);
+                setStepDirection(-1);
+                setStep(ModalStep.ACCOUNT_MAIN);
+            }
+        }
+    }), [evmSwitchChain, cosmosSwitchChain]);
+    const connectExternalWallet = useCallback((wallet, isMobileConnect, isManualWalletConnect, isResetAfterManualWalletConnect) => __awaiter(this, void 0, void 0, function* () {
+        // If triggering the WC modal manually from desktop, disconnect the current connection attempt to trigger the mobile connection attempt
+        if (isExternalWalletConnecting && isManualWalletConnect) {
+            yield evmDisconnect();
+            yield solanaDisconnect();
+            yield cosmosDisconnect();
+            setQrUri(undefined);
+            setIsExternalWalletConnecting(false);
+        }
+        if (isResetAfterManualWalletConnect || isManualWalletConnect || !isExternalWalletConnecting) {
+            setExternalWalletError();
+            setIsExternalWalletConnecting(true);
+            setIsUsingMobileConnector(isMobileConnect);
+            const { address, error } = yield (isMobileConnect ? wallet.connectMobile(isManualWalletConnect) : wallet.connect());
+            if (error) {
+                setExternalWalletError([error]);
+                setIsUsingMobileConnector();
+                // If triggering the WC modal manually from desktop, attempt desktop reconnect on connection rejection
+                if (isManualWalletConnect && error === 'Connection request rejected') {
+                    setExternalWalletError();
+                    yield connectExternalWallet(wallet, false, false, true);
+                    yield updateQrUri();
+                    return;
+                }
+            }
+            else if (address) {
+                setStep(ModalStep.LOGIN_DONE);
+            }
+            setIsExternalWalletConnecting(false);
+        }
+    }), [isExternalWalletConnecting]);
+    const disconnectExternalWallet = () => __awaiter(this, void 0, void 0, function* () {
+        yield evmDisconnect();
+        yield solanaDisconnect();
+        yield cosmosDisconnect();
+        setSelectedExternalWalletId();
+    });
+    const walletDisplayHelpers = {
+        // 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 || wallet === void 0 ? void 0 : wallet.isExtension) && (wallet === null || wallet === void 0 ? void 0 : wallet.installed)) || !(wallet === null || wallet === void 0 ? void 0 : wallet.isMobile) || (wallet === null || wallet === void 0 ? void 0 : wallet.type) === WalletType.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 || wallet === void 0 ? void 0 : wallet.isMobile)) || (!isMobile() && !(wallet === null || wallet === void 0 ? void 0 : wallet.installed)),
+        isSolanaMobileIOS: isIOS() && isMobile() && !isIOSWebview() && (wallet === null || wallet === void 0 ? void 0 : wallet.type) === WalletType.SOLANA,
+        isCosmosMobileWallet: (wallet === null || wallet === void 0 ? void 0 : wallet.type) === WalletType.COSMOS && isUsingMobileConnector,
+    };
+    const username = useMemo(() => {
+        var _a, _b;
+        let username;
+        const storedExternalWallet = para.externalWallets[(_b = (_a = para.currentExternalWalletAddresses) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : ''];
+        if (storedExternalWallet) {
+            const walletType = storedExternalWallet === null || storedExternalWallet === void 0 ? void 0 : storedExternalWallet.type;
+            switch (walletType) {
+                case WalletType.EVM: {
+                    // If evmUsername is an EVM address, format it, else return it since it should be an ENS name
+                    username = evmUsername
+                        ? evmUsername.startsWith('0x')
+                            ? truncateAddress(evmUsername, 'EVM')
+                            : evmUsername
+                        : undefined;
+                    break;
+                }
+                default: {
+                    username = storedExternalWallet.address
+                        ? truncateAddress(storedExternalWallet.address, storedExternalWallet.type)
+                        : undefined;
+                    break;
+                }
+            }
+        }
+        return username;
+    }, [evmUsername, wallet]);
+    const avatar = useMemo(() => {
+        var _a, _b, _c;
+        const walletType = (_c = para.externalWallets[(_b = (_a = para.currentExternalWalletAddresses) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : '']) === null || _c === void 0 ? void 0 : _c.type;
+        if (walletType) {
+            switch (walletType) {
+                case WalletType.EVM: {
+                    return evmAvatar;
+                }
+                default: {
+                    return undefined;
+                }
+            }
+        }
+    }, [evmAvatar, wallet]);
+    return (_jsx(ExternalWalletContext.Provider, { value: useMemo(() => ({
+            wallets,
+            chains,
+            chainId,
+            wallet,
+            qrUri,
+            walletDisplayHelpers,
+            chainIdSwitchingTo,
+            username,
+            avatar,
+            connectExternalWallet,
+            disconnectExternalWallet,
+            switchChain,
+            setChainIdSwitchingTo,
+        }), [
+            wallets,
+            chains,
+            chainId,
+            wallet,
+            qrUri,
+            walletDisplayHelpers,
+            chainIdSwitchingTo,
+            username,
+            avatar,
+            disconnectExternalWallet,
+            connectExternalWallet,
+            switchChain,
+            setChainIdSwitchingTo,
+        ]), children: children }));
+}
+export const useExternalWallets = () => useContext(ExternalWalletContext);

package/dist/modal/providers/SolanaExternalWalletContextStub.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { CommonWallet } from '../types/commonTypes.js';
+import ParaWeb from '@getpara/web-sdk';
+export declare const defaultSolanaExternalWallet: {
+    wallets: any[];
+    disconnect: () => Promise<void>;
+};
+export type SolanaExternalWalletContextType = {
+    wallets: CommonWallet[];
+    disconnect: () => Promise<void>;
+};
+export declare const SolanaExternalWalletContext: import("react").Context<SolanaExternalWalletContextType>;
+export interface SolanaExternalWalletProviderProps {
+    children: ReactNode;
+    para: ParaWeb;
+    onSwitchWallet: (args: {
+        address?: string;
+        error?: string;
+    }) => void;
+}
+export declare function SolanaExternalWalletProvider({ children }: SolanaExternalWalletProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/modal/providers/SolanaExternalWalletContextStub.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useMemo } from 'react';
+export const defaultSolanaExternalWallet = {
+    wallets: [],
+    disconnect: () => Promise.resolve(),
+};
+export const SolanaExternalWalletContext = createContext(defaultSolanaExternalWallet);
+export function SolanaExternalWalletProvider({ children }) {
+    const wallets = [];
+    const disconnect = () => Promise.resolve();
+    return (_jsx(SolanaExternalWalletContext.Provider, { value: useMemo(() => ({ wallets, disconnect }), [wallets, disconnect]), children: children }));
+}

package/dist/modal/stores/externalWalletProvider/actions.d.ts

@@ -0,0 +1,3 @@
+import { StoreApi } from 'zustand';
+import { ExternalWalletProviderActions, ExternalWalletProviderStore } from './useExternalWalletProviderStore.js';
+export declare const getActions: (set: StoreApi<ExternalWalletProviderStore>["setState"]) => ExternalWalletProviderActions;

package/dist/modal/stores/externalWalletProvider/actions.js

@@ -0,0 +1,5 @@
+export const getActions = (set) => ({
+    updateState: state => {
+        set(state);
+    },
+});