@dynamic-labs/sdk-react-core 0.18.0-RC.2 → 0.18.0-RC.21

package/src/lib/utils/hooks/useConnectWallet/useConnectWallet.cjs

@@ -23,91 +23,100 @@ var api = require('../../../data/api.cjs');
 require('@dynamic-labs/multi-wallet');
 var shouldManuallyReconnectOnRefresh = require('../../functions/shouldManuallyReconnectOnRefresh/shouldManuallyReconnectOnRefresh.cjs');
 
-const useConnectWallet = (wallets, authMode, environmentId, enableVisitTrackingOnConnectOnly, primaryWalletId, setPrimaryWalletId) => {
+const useConnectWallet = ({ authMode, clearPrimaryWalletId, enableVisitTrackingOnConnectOnly, environmentId, primaryWalletId, setPrimaryWalletId, wallets, onUnlink, onBeforeConnectSuccessConfirmation, setShowAuthFlow, }) => {
     const [connectedWalletsInfo, setConnectedWalletsInfo, removeConnectedWalletsInfo,] = useLocalStorage.useLocalStorage(localStorage.CONNECTED_WALLETS_INFO, []);
-    const [connectedWallet, setConnectedWallet] = React.useState(null);
     const [connectedWallets, setConnectedWallets] = React.useState([]);
-    const setConnectedStates = React.useCallback((walletConnector, address, chain, id) => {
-        setConnectedWallet({
-            address,
-            chain,
-            connected: true,
-            connector: walletConnector,
-            id: 'connect-only-wallet',
-        });
-        setConnectedWallets((currentWallets) => {
-            const exists = currentWallets.some((currentWallet) => walletConnectorCore.isSameAddress(currentWallet.address, address, chain));
-            if (currentWallets.length === 0 &&
-                authMode === 'connect-only' &&
-                !primaryWalletId) {
-                setPrimaryWalletId(`connect-only-wallet-${0}`);
-            }
-            if (exists) {
-                return currentWallets;
-            }
-            return [
-                ...currentWallets,
-                {
-                    address,
-                    chain,
-                    connected: true,
-                    connector: walletConnector,
-                    id: `connect-only-wallet-${id}`,
-                },
-            ];
-        });
-        setConnectedWalletsInfo((currentWallets) => {
-            const exists = currentWallets.some((currentWallet) => currentWallet.walletPublicKey === address);
-            if (exists) {
-                return currentWallets;
-            }
-            return [
-                ...currentWallets,
-                {
-                    chain,
-                    name: walletConnector.name,
-                    provider: getWalletProvider.getWalletProvider(walletConnector),
-                    walletPublicKey: address,
-                },
-            ];
-        });
-    }, [authMode, primaryWalletId, setConnectedWalletsInfo, setPrimaryWalletId]);
-    const connectWalletByAddressAndChain = React.useCallback((name, address, chain, id) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
-        const walletConnector = walletConnectorCore.getWalletConnectorByName(wallets.map((wallet) => wallet.walletConnector), name);
-        if (walletConnector) {
-            if (shouldManuallyReconnectOnRefresh.shouldManuallyReconnectOnRefresh(walletConnector)) {
-                yield walletConnector.connect();
-            }
-            const connectedAccounts = yield walletConnector.getConnectedAccounts();
-            const result = connectedAccounts.filter((account) => walletConnectorCore.isSameAddress(account, address, chain));
-            if (result.length > 0) {
-                walletConnector.connect();
-                setConnectedStates(walletConnector, address, chain, id);
+    // The function to update and define the connectedWallets list.
+    // It uses walletConnector to get the current wallet address and network
+    // The address and network in the runtime are updated by the event listeners
+    // The event listeners are updating `connectedWallets` list.
+    // It should be called on the first render and when connectedWalletsInfo updates
+    const updateConnectedWalletsList = React.useCallback(() => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        const walletConnectors = wallets.map((wallet) => wallet.walletConnector);
+        if (!walletConnectors.length) {
+            return;
+        }
+        const nextConnectedWallets = (yield Promise.all(connectedWalletsInfo.map((storedConnectedWalletInfo) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+            const walletConnector = walletConnectorCore.getWalletConnectorByName(walletConnectors, storedConnectedWalletInfo.walletConnectorKey);
+            if (!walletConnector) {
+                walletConnectorCore.logger.error('Could not find walletConnector: ' +
+                    storedConnectedWalletInfo.walletConnectorKey);
+                return Promise.resolve(null);
             }
-            else {
-                setConnectedWallet(null);
+            const [walletAddress] = yield walletConnector.getConnectedAccounts();
+            const walletNetwork = yield walletConnector.getNetwork();
+            const walletChain = walletConnector.connectedChain;
+            const walletObject = {
+                address: 
+                // We use `storedConnectedWalletInfo.lastWalletAddress` as a workaround to Braavos issue
+                // Braavos during initialization returns an empty string as a wallet address
+                walletAddress ||
+                    storedConnectedWalletInfo.lastWalletAddress ||
+                    '',
+                chain: walletChain || '',
+                connected: true,
+                connector: walletConnector,
+                id: storedConnectedWalletInfo.id,
+                network: walletNetwork,
+            };
+            return Promise.resolve(walletObject);
+        })))).filter((wallet) => Boolean(wallet));
+        setConnectedWallets(nextConnectedWallets);
+    }), [connectedWalletsInfo, wallets]);
+    // Generate the connectedWallets list when connectedWalletsInfo (localStorage) or memoized wallet connector updates
+    React.useEffect(() => {
+        updateConnectedWalletsList();
+    }, [updateConnectedWalletsList]);
+    const getNextIdAvailable = React.useCallback((currentWallets) => {
+        const existingIds = currentWallets.map(({ id }) => id);
+        const sortedIds = existingIds
+            .map((id) => Number(id.replace('connect-wallet-', '')))
+            .sort((a, b) => a - b);
+        for (let i = 0; i < sortedIds.length; i++) {
+            if (sortedIds[i] !== i) {
+                return i;
             }
         }
-        else {
-            setConnectedWallet(null);
+        return sortedIds.length;
+    }, []);
+    const updateConnectedWalletById = React.useCallback((walletId, walletObject) => {
+        const clonedConnectedWalletsList = [...connectedWallets];
+        const connectedWalletIndex = clonedConnectedWalletsList.findIndex((connectedWallet) => connectedWallet.id === walletId);
+        if (connectedWalletIndex > -1) {
+            clonedConnectedWalletsList[connectedWalletIndex] = Object.assign(Object.assign({}, clonedConnectedWalletsList[connectedWalletIndex]), walletObject);
+            setConnectedWallets(clonedConnectedWalletsList);
         }
-    }), [setConnectedStates, wallets]);
-    React.useEffect(() => {
-        if (authMode === 'connect-only' &&
-            connectedWalletsInfo.length &&
-            !connectedWallets.length) {
-            connectedWalletsInfo.forEach(({ name, walletPublicKey, chain }, id) => {
-                if (chain) {
-                    connectWalletByAddressAndChain(name, walletPublicKey, chain, id);
-                }
-            });
+    }, [connectedWallets]);
+    const connectedWallet = connectedWallets[0] || null;
+    // Keeps connected wallet data inside localStorage
+    const applyConnectedWalletToStore = ({ walletId, walletAddress, walletConnectorKey, walletChain, provider, }) => {
+        const nextConnectedWalletsInfo = [...connectedWalletsInfo];
+        nextConnectedWalletsInfo.push({
+            id: walletId,
+            lastWalletAddress: walletAddress,
+            provider,
+            walletChain,
+            walletConnectorKey,
+        });
+        setConnectedWalletsInfo(nextConnectedWalletsInfo);
+        return Promise.resolve();
+    };
+    // Updates connected wallet (network and address) and verifies connected wallet connection
+    const refreshConnectedWallet = (walletId, walletConnector) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        if (shouldManuallyReconnectOnRefresh.shouldManuallyReconnectOnRefresh(walletConnector)) {
+            yield walletConnector.connect();
         }
-    }, [
-        authMode,
-        connectWalletByAddressAndChain,
-        connectedWallets.length,
-        connectedWalletsInfo,
-    ]);
+        const currentWalletConnectorAddress = yield walletConnector.fetchPublicAddress();
+        if (!currentWalletConnectorAddress) {
+            walletConnectorCore.logger.error('Could not refresh the wallet. The wallet address is not available');
+            return;
+        }
+        const currentWalletConnectoNetwork = yield walletConnector.getNetwork();
+        updateConnectedWalletById(walletId, {
+            address: currentWalletConnectorAddress,
+            network: currentWalletConnectoNetwork,
+        });
+    });
     const shouldSkipCreatingVisit = React.useMemo(() => (authMode === 'connect-only' && !enableVisitTrackingOnConnectOnly) ||
         connectedWallet, [authMode, connectedWallet, enableVisitTrackingOnConnectOnly]);
     const connectWallet = (walletConnector, fetchPublicAddressOpts) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
@@ -117,33 +126,66 @@ const useConnectWallet = (wallets, authMode, environmentId, enableVisitTrackingO
             error.code = 'missing-public-address';
             throw error;
         }
-        const chain = walletConnector.connectedChain || '';
-        setConnectedStates(walletConnector, publicWalletAddress, chain, connectedWalletsInfo.length);
+        if (onBeforeConnectSuccessConfirmation) {
+            const shouldProceedWithConnection = yield onBeforeConnectSuccessConfirmation(publicWalletAddress);
+            if (!shouldProceedWithConnection) {
+                walletConnectorCore.logger.info('Connection was not established because onBeforeConnectSuccessConfirmation returned false');
+                setShowAuthFlow(false);
+                return;
+            }
+        }
+        const walletId = `connect-wallet-${getNextIdAvailable(connectedWalletsInfo)}`;
+        if (!primaryWalletId) {
+            setPrimaryWalletId(walletId);
+        }
+        const walletChain = walletConnector.connectedChain;
+        const isWalletStored = connectedWalletsInfo.some(({ walletConnectorKey: storedWalletConnectorKey }) => storedWalletConnectorKey === walletConnector.name);
+        if (isWalletStored) {
+            yield updateConnectedWalletsList();
+        }
+        else {
+            applyConnectedWalletToStore({
+                provider: getWalletProvider.getWalletProvider(walletConnector),
+                walletAddress: publicWalletAddress,
+                walletChain,
+                walletConnectorKey: walletConnector.name,
+                walletId,
+            });
+        }
         if (shouldSkipCreatingVisit) {
-            return publicWalletAddress;
+            return Promise.resolve(publicWalletAddress);
         }
         // send information to backend to kick off background jobs
         // so verify/sign on the next step could go by more quickly
         // this is async work, but DO NOT AWAIT
         api.createVisit({
             authMode,
-            chain,
+            chain: walletChain || '',
             environmentId,
             publicWalletAddress,
             walletName: walletConnector.name,
             walletProvider: getWalletProvider.getWalletProvider(walletConnector),
         });
-        return publicWalletAddress;
+        return Promise.resolve(publicWalletAddress);
     });
+    const unlinkConnectedWallet = (walletId) => {
+        const filteredWallets = connectedWalletsInfo.filter((wallet) => wallet.id !== walletId);
+        if (walletId === primaryWalletId) {
+            clearPrimaryWalletId();
+        }
+        setConnectedWalletsInfo(filteredWallets);
+        onUnlink === null || onUnlink === void 0 ? void 0 : onUnlink(walletId, filteredWallets);
+    };
+    const getConnectedWalletById = React.useCallback((walletId) => connectedWallets.find((wallet) => wallet.id === walletId), [connectedWallets]);
     return {
         connectWallet,
-        connectWalletByAddressAndChain,
         connectedWallet,
         connectedWallets,
         connectedWalletsInfo,
+        getConnectedWalletById,
+        refreshConnectedWallet,
         removeConnectedWalletsInfo,
-        setConnectedWallet,
-        setConnectedWallets,
+        unlinkConnectedWallet,
     };
 };
 

package/src/lib/utils/hooks/useConnectWallet/useConnectWallet.d.ts

@@ -1,19 +1,33 @@
-/// <reference types="react" />
+import { Dispatch, SetStateAction } from 'react';
 import { Chain, FetchPublicAddressOpts, WalletConnector } from '@dynamic-labs/wallet-connector-core';
-import { AuthModeType, Wallet, WalletOption } from '../../../shared';
+import { AuthModeType, OnBeforeConnectSuccessConfirmation, Wallet, WalletOption } from '../../../shared';
 export type ConnectedWalletConnectorType = {
-    chain: Chain | undefined;
-    name: string;
+    id: string;
+    walletChain?: Chain;
+    walletConnectorKey: string;
     provider: string;
-    walletPublicKey: string;
+    lastWalletAddress?: string;
 };
-export declare const useConnectWallet: (wallets: WalletOption[], authMode: AuthModeType, environmentId: string, enableVisitTrackingOnConnectOnly: boolean, primaryWalletId: string | undefined, setPrimaryWalletId: (walletId: string) => void) => {
-    connectWallet: (walletConnector: WalletConnector, fetchPublicAddressOpts?: FetchPublicAddressOpts) => Promise<string>;
-    connectWalletByAddressAndChain: (name: string, address: string, chain: Chain, id?: number) => Promise<void>;
-    connectedWallet: Wallet | null;
-    connectedWallets: [] | Wallet[];
-    connectedWalletsInfo: [] | ConnectedWalletConnectorType[];
+type Props = {
+    authMode: AuthModeType;
+    clearPrimaryWalletId: () => void;
+    enableVisitTrackingOnConnectOnly: boolean;
+    environmentId: string;
+    primaryWalletId: string | undefined;
+    setPrimaryWalletId: (walletId: string) => void;
+    wallets: WalletOption[];
+    onUnlink?: (walletId: string, connectedWalletsInfo: ConnectedWalletConnectorType[]) => void;
+    onBeforeConnectSuccessConfirmation: OnBeforeConnectSuccessConfirmation | undefined;
+    setShowAuthFlow: Dispatch<SetStateAction<boolean>>;
+};
+export declare const useConnectWallet: ({ authMode, clearPrimaryWalletId, enableVisitTrackingOnConnectOnly, environmentId, primaryWalletId, setPrimaryWalletId, wallets, onUnlink, onBeforeConnectSuccessConfirmation, setShowAuthFlow, }: Props) => {
+    connectWallet: (walletConnector: WalletConnector, fetchPublicAddressOpts?: FetchPublicAddressOpts) => Promise<string | undefined>;
+    connectedWallet: Wallet;
+    connectedWallets: Wallet[];
+    connectedWalletsInfo: ConnectedWalletConnectorType[] | [];
+    getConnectedWalletById: (walletId: string) => Wallet | undefined;
+    refreshConnectedWallet: (walletId: string, walletConnector: WalletConnector) => Promise<void>;
     removeConnectedWalletsInfo: () => void;
-    setConnectedWallet: import("react").Dispatch<import("react").SetStateAction<Wallet | null>>;
-    setConnectedWallets: import("react").Dispatch<import("react").SetStateAction<[] | Wallet[]>>;
+    unlinkConnectedWallet: (walletId: string) => void;
 };
+export {};

package/src/lib/utils/hooks/useConnectWallet/useConnectWallet.js

@@ -1,6 +1,6 @@
 import { __awaiter } from '../../../../../_virtual/_tslib.js';
 import { useState, useCallback, useEffect, useMemo } from 'react';
-import { isSameAddress, getWalletConnectorByName } from '@dynamic-labs/wallet-connector-core';
+import { getWalletConnectorByName, logger } from '@dynamic-labs/wallet-connector-core';
 import '@dynamic-labs/sdk-api';
 import '../../../shared/logger.js';
 import '@dynamic-labs/iconic';
@@ -19,91 +19,100 @@ import { createVisit } from '../../../data/api.js';
 import '@dynamic-labs/multi-wallet';
 import { shouldManuallyReconnectOnRefresh } from '../../functions/shouldManuallyReconnectOnRefresh/shouldManuallyReconnectOnRefresh.js';
 
-const useConnectWallet = (wallets, authMode, environmentId, enableVisitTrackingOnConnectOnly, primaryWalletId, setPrimaryWalletId) => {
+const useConnectWallet = ({ authMode, clearPrimaryWalletId, enableVisitTrackingOnConnectOnly, environmentId, primaryWalletId, setPrimaryWalletId, wallets, onUnlink, onBeforeConnectSuccessConfirmation, setShowAuthFlow, }) => {
     const [connectedWalletsInfo, setConnectedWalletsInfo, removeConnectedWalletsInfo,] = useLocalStorage(CONNECTED_WALLETS_INFO, []);
-    const [connectedWallet, setConnectedWallet] = useState(null);
     const [connectedWallets, setConnectedWallets] = useState([]);
-    const setConnectedStates = useCallback((walletConnector, address, chain, id) => {
-        setConnectedWallet({
-            address,
-            chain,
-            connected: true,
-            connector: walletConnector,
-            id: 'connect-only-wallet',
-        });
-        setConnectedWallets((currentWallets) => {
-            const exists = currentWallets.some((currentWallet) => isSameAddress(currentWallet.address, address, chain));
-            if (currentWallets.length === 0 &&
-                authMode === 'connect-only' &&
-                !primaryWalletId) {
-                setPrimaryWalletId(`connect-only-wallet-${0}`);
-            }
-            if (exists) {
-                return currentWallets;
-            }
-            return [
-                ...currentWallets,
-                {
-                    address,
-                    chain,
-                    connected: true,
-                    connector: walletConnector,
-                    id: `connect-only-wallet-${id}`,
-                },
-            ];
-        });
-        setConnectedWalletsInfo((currentWallets) => {
-            const exists = currentWallets.some((currentWallet) => currentWallet.walletPublicKey === address);
-            if (exists) {
-                return currentWallets;
-            }
-            return [
-                ...currentWallets,
-                {
-                    chain,
-                    name: walletConnector.name,
-                    provider: getWalletProvider(walletConnector),
-                    walletPublicKey: address,
-                },
-            ];
-        });
-    }, [authMode, primaryWalletId, setConnectedWalletsInfo, setPrimaryWalletId]);
-    const connectWalletByAddressAndChain = useCallback((name, address, chain, id) => __awaiter(void 0, void 0, void 0, function* () {
-        const walletConnector = getWalletConnectorByName(wallets.map((wallet) => wallet.walletConnector), name);
-        if (walletConnector) {
-            if (shouldManuallyReconnectOnRefresh(walletConnector)) {
-                yield walletConnector.connect();
-            }
-            const connectedAccounts = yield walletConnector.getConnectedAccounts();
-            const result = connectedAccounts.filter((account) => isSameAddress(account, address, chain));
-            if (result.length > 0) {
-                walletConnector.connect();
-                setConnectedStates(walletConnector, address, chain, id);
+    // The function to update and define the connectedWallets list.
+    // It uses walletConnector to get the current wallet address and network
+    // The address and network in the runtime are updated by the event listeners
+    // The event listeners are updating `connectedWallets` list.
+    // It should be called on the first render and when connectedWalletsInfo updates
+    const updateConnectedWalletsList = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        const walletConnectors = wallets.map((wallet) => wallet.walletConnector);
+        if (!walletConnectors.length) {
+            return;
+        }
+        const nextConnectedWallets = (yield Promise.all(connectedWalletsInfo.map((storedConnectedWalletInfo) => __awaiter(void 0, void 0, void 0, function* () {
+            const walletConnector = getWalletConnectorByName(walletConnectors, storedConnectedWalletInfo.walletConnectorKey);
+            if (!walletConnector) {
+                logger.error('Could not find walletConnector: ' +
+                    storedConnectedWalletInfo.walletConnectorKey);
+                return Promise.resolve(null);
             }
-            else {
-                setConnectedWallet(null);
+            const [walletAddress] = yield walletConnector.getConnectedAccounts();
+            const walletNetwork = yield walletConnector.getNetwork();
+            const walletChain = walletConnector.connectedChain;
+            const walletObject = {
+                address: 
+                // We use `storedConnectedWalletInfo.lastWalletAddress` as a workaround to Braavos issue
+                // Braavos during initialization returns an empty string as a wallet address
+                walletAddress ||
+                    storedConnectedWalletInfo.lastWalletAddress ||
+                    '',
+                chain: walletChain || '',
+                connected: true,
+                connector: walletConnector,
+                id: storedConnectedWalletInfo.id,
+                network: walletNetwork,
+            };
+            return Promise.resolve(walletObject);
+        })))).filter((wallet) => Boolean(wallet));
+        setConnectedWallets(nextConnectedWallets);
+    }), [connectedWalletsInfo, wallets]);
+    // Generate the connectedWallets list when connectedWalletsInfo (localStorage) or memoized wallet connector updates
+    useEffect(() => {
+        updateConnectedWalletsList();
+    }, [updateConnectedWalletsList]);
+    const getNextIdAvailable = useCallback((currentWallets) => {
+        const existingIds = currentWallets.map(({ id }) => id);
+        const sortedIds = existingIds
+            .map((id) => Number(id.replace('connect-wallet-', '')))
+            .sort((a, b) => a - b);
+        for (let i = 0; i < sortedIds.length; i++) {
+            if (sortedIds[i] !== i) {
+                return i;
             }
         }
-        else {
-            setConnectedWallet(null);
+        return sortedIds.length;
+    }, []);
+    const updateConnectedWalletById = useCallback((walletId, walletObject) => {
+        const clonedConnectedWalletsList = [...connectedWallets];
+        const connectedWalletIndex = clonedConnectedWalletsList.findIndex((connectedWallet) => connectedWallet.id === walletId);
+        if (connectedWalletIndex > -1) {
+            clonedConnectedWalletsList[connectedWalletIndex] = Object.assign(Object.assign({}, clonedConnectedWalletsList[connectedWalletIndex]), walletObject);
+            setConnectedWallets(clonedConnectedWalletsList);
         }
-    }), [setConnectedStates, wallets]);
-    useEffect(() => {
-        if (authMode === 'connect-only' &&
-            connectedWalletsInfo.length &&
-            !connectedWallets.length) {
-            connectedWalletsInfo.forEach(({ name, walletPublicKey, chain }, id) => {
-                if (chain) {
-                    connectWalletByAddressAndChain(name, walletPublicKey, chain, id);
-                }
-            });
+    }, [connectedWallets]);
+    const connectedWallet = connectedWallets[0] || null;
+    // Keeps connected wallet data inside localStorage
+    const applyConnectedWalletToStore = ({ walletId, walletAddress, walletConnectorKey, walletChain, provider, }) => {
+        const nextConnectedWalletsInfo = [...connectedWalletsInfo];
+        nextConnectedWalletsInfo.push({
+            id: walletId,
+            lastWalletAddress: walletAddress,
+            provider,
+            walletChain,
+            walletConnectorKey,
+        });
+        setConnectedWalletsInfo(nextConnectedWalletsInfo);
+        return Promise.resolve();
+    };
+    // Updates connected wallet (network and address) and verifies connected wallet connection
+    const refreshConnectedWallet = (walletId, walletConnector) => __awaiter(void 0, void 0, void 0, function* () {
+        if (shouldManuallyReconnectOnRefresh(walletConnector)) {
+            yield walletConnector.connect();
         }
-    }, [
-        authMode,
-        connectWalletByAddressAndChain,
-        connectedWallets.length,
-        connectedWalletsInfo,
-    ]);
+        const currentWalletConnectorAddress = yield walletConnector.fetchPublicAddress();
+        if (!currentWalletConnectorAddress) {
+            logger.error('Could not refresh the wallet. The wallet address is not available');
+            return;
+        }
+        const currentWalletConnectoNetwork = yield walletConnector.getNetwork();
+        updateConnectedWalletById(walletId, {
+            address: currentWalletConnectorAddress,
+            network: currentWalletConnectoNetwork,
+        });
+    });
     const shouldSkipCreatingVisit = useMemo(() => (authMode === 'connect-only' && !enableVisitTrackingOnConnectOnly) ||
         connectedWallet, [authMode, connectedWallet, enableVisitTrackingOnConnectOnly]);
     const connectWallet = (walletConnector, fetchPublicAddressOpts) => __awaiter(void 0, void 0, void 0, function* () {
@@ -113,33 +122,66 @@ const useConnectWallet = (wallets, authMode, environmentId, enableVisitTrackingO
             error.code = 'missing-public-address';
             throw error;
         }
-        const chain = walletConnector.connectedChain || '';
-        setConnectedStates(walletConnector, publicWalletAddress, chain, connectedWalletsInfo.length);
+        if (onBeforeConnectSuccessConfirmation) {
+            const shouldProceedWithConnection = yield onBeforeConnectSuccessConfirmation(publicWalletAddress);
+            if (!shouldProceedWithConnection) {
+                logger.info('Connection was not established because onBeforeConnectSuccessConfirmation returned false');
+                setShowAuthFlow(false);
+                return;
+            }
+        }
+        const walletId = `connect-wallet-${getNextIdAvailable(connectedWalletsInfo)}`;
+        if (!primaryWalletId) {
+            setPrimaryWalletId(walletId);
+        }
+        const walletChain = walletConnector.connectedChain;
+        const isWalletStored = connectedWalletsInfo.some(({ walletConnectorKey: storedWalletConnectorKey }) => storedWalletConnectorKey === walletConnector.name);
+        if (isWalletStored) {
+            yield updateConnectedWalletsList();
+        }
+        else {
+            applyConnectedWalletToStore({
+                provider: getWalletProvider(walletConnector),
+                walletAddress: publicWalletAddress,
+                walletChain,
+                walletConnectorKey: walletConnector.name,
+                walletId,
+            });
+        }
         if (shouldSkipCreatingVisit) {
-            return publicWalletAddress;
+            return Promise.resolve(publicWalletAddress);
         }
         // send information to backend to kick off background jobs
         // so verify/sign on the next step could go by more quickly
         // this is async work, but DO NOT AWAIT
         createVisit({
             authMode,
-            chain,
+            chain: walletChain || '',
             environmentId,
             publicWalletAddress,
             walletName: walletConnector.name,
             walletProvider: getWalletProvider(walletConnector),
         });
-        return publicWalletAddress;
+        return Promise.resolve(publicWalletAddress);
     });
+    const unlinkConnectedWallet = (walletId) => {
+        const filteredWallets = connectedWalletsInfo.filter((wallet) => wallet.id !== walletId);
+        if (walletId === primaryWalletId) {
+            clearPrimaryWalletId();
+        }
+        setConnectedWalletsInfo(filteredWallets);
+        onUnlink === null || onUnlink === void 0 ? void 0 : onUnlink(walletId, filteredWallets);
+    };
+    const getConnectedWalletById = useCallback((walletId) => connectedWallets.find((wallet) => wallet.id === walletId), [connectedWallets]);
     return {
         connectWallet,
-        connectWalletByAddressAndChain,
         connectedWallet,
         connectedWallets,
         connectedWalletsInfo,
+        getConnectedWalletById,
+        refreshConnectedWallet,
         removeConnectedWalletsInfo,
-        setConnectedWallet,
-        setConnectedWallets,
+        unlinkConnectedWallet,
     };
 };
 

package/src/lib/utils/hooks/useConnectWithEmail/index.d.ts

@@ -0,0 +1 @@
+export { useConnectWithEmail } from './useConnectWithEmail';

package/src/lib/utils/hooks/useConnectWithEmail/useConnectWithEmail.cjs

@@ -17,14 +17,17 @@ require('../../../shared/utils/classes/storage/localStorage.cjs');
 require('ethers');
 require('../../../shared/consts/index.cjs');
 var ErrorContext = require('../../../context/ErrorContext/ErrorContext.cjs');
+var useInternalDynamicContext = require('../../../context/DynamicContext/useInternalDynamicContext.cjs');
 
 const useConnectWithEmail = ({ emailWalletConnector, handleConnect, }) => {
     const { error } = ErrorContext.useErrorContext();
-    const [email, setEmail] = React.useState('');
     const [loading, setLoading] = React.useState(false);
-    const connectWithEmail = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { setIsVerificationInProgress } = useInternalDynamicContext.useInternalDynamicContext();
+    const connectWithEmail = (email) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
         if (!email || !emailWalletConnector || loading)
             return;
+        // Indicate auth verification process start
+        setIsVerificationInProgress(true);
         setLoading(true);
         emailWalletConnector.setEmail(email);
         try {
@@ -32,6 +35,7 @@ const useConnectWithEmail = ({ emailWalletConnector, handleConnect, }) => {
         }
         catch (e) {
             logger.logger.error(e);
+            setIsVerificationInProgress(false);
             setLoading(false);
         }
     });
@@ -42,9 +46,7 @@ const useConnectWithEmail = ({ emailWalletConnector, handleConnect, }) => {
     }, [error, loading]);
     return {
         connectWithEmail,
-        email,
         loading,
-        setEmail,
     };
 };
 

package/src/lib/utils/hooks/useConnectWithEmail/useConnectWithEmail.d.ts

@@ -1,13 +1,10 @@
-/// <reference types="react" />
 import { IEmailWalletConnector, WalletConnector } from '@dynamic-labs/wallet-connector-core';
 type ConnectWithEmailProps = {
     emailWalletConnector: IEmailWalletConnector | undefined;
     handleConnect: (walletConnector: WalletConnector) => Promise<void>;
 };
 export declare const useConnectWithEmail: ({ emailWalletConnector, handleConnect, }: ConnectWithEmailProps) => {
-    connectWithEmail: () => Promise<void>;
-    email: string;
+    connectWithEmail: (email: string) => Promise<void>;
     loading: boolean;
-    setEmail: import("react").Dispatch<import("react").SetStateAction<string>>;
 };
 export {};