@dynamic-labs/wagmi-connector 3.0.0-alpha.51 → 3.0.0-alpha.53

package/src/lib/Connector.js

@@ -3,7 +3,8 @@ import { __awaiter } from '../../_virtual/_tslib.js';
 import { createConnector } from '@wagmi/core';
 import { getAddress, createWalletClient, custom } from 'viem';
 
-const getCreateConnectorFn = ({ connectorId, wallet, preventWagmiSyncFromCallingLogout, handleLogOut, }) => createConnector((config) => ({
+/* eslint-disable prefer-arrow/prefer-arrow-functions */
+const getCreateConnectorFn = ({ connectorId, wallet, }) => createConnector((config) => ({
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!wallet.connector) {
@@ -21,20 +22,9 @@ const getCreateConnectorFn = ({ connectorId, wallet, preventWagmiSyncFromCalling
     },
     disconnect() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!preventWagmiSyncFromCallingLogout.current) {
-                yield wallet.connector.endSession();
-                yield handleLogOut();
-            }
             wallet.connector.off('accountChange', this.handleAccountsChange.bind(this));
             wallet.connector.off('chainChange', this.handleChainChange.bind(this));
             wallet.connector.off('disconnect', this.onDisconnect.bind(this));
-            /**
-             * In our own Dynamic Wagmi sync component, we will flip the flag to true before calling disconnect,
-             * and here it automatically flips back to false afterwards. This will prevent the Connector from
-             * calling handleLogOut when we are the ones calling disconnect, but will preserve the existing behavior
-             * for customers who use useDisconnect directly.
-             */
-            preventWagmiSyncFromCallingLogout.current = false;
         });
     },
     getAccounts() {
@@ -44,7 +34,7 @@ const getCreateConnectorFn = ({ connectorId, wallet, preventWagmiSyncFromCalling
     },
     getChainId() {
         return __awaiter(this, void 0, void 0, function* () {
-            const network = yield wallet.getNetwork();
+            const network = yield wallet.connector.getNetwork();
             if (!network) {
                 throw new Error('Network is not defined');
             }
@@ -54,16 +44,17 @@ const getCreateConnectorFn = ({ connectorId, wallet, preventWagmiSyncFromCalling
     getClient(args) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
-            const signer = yield wallet.getSigner();
-            if (signer.account && signer.chain) {
-                return signer;
+            const walletClient = yield wallet.getWalletClient();
+            if (walletClient.account && walletClient.chain) {
+                return walletClient;
             }
-            const walletClient = createWalletClient({
-                account: (_a = (yield this.getAccounts())) === null || _a === void 0 ? void 0 : _a[0],
-                chain: (_b = config.chains.find((chain) => chain.id === (args === null || args === void 0 ? void 0 : args.chainId))) !== null && _b !== void 0 ? _b : config.chains[0],
-                transport: custom(signer),
+            const client = createWalletClient({
+                account: walletClient.account || ((_a = (yield this.getAccounts())) === null || _a === void 0 ? void 0 : _a[0]),
+                chain: (_b = (walletClient.chain ||
+                    config.chains.find((chain) => chain.id === (args === null || args === void 0 ? void 0 : args.chainId)))) !== null && _b !== void 0 ? _b : config.chains[0],
+                transport: custom(walletClient),
             });
-            return walletClient;
+            return client;
         });
     },
     getProvider() {
@@ -82,14 +73,14 @@ const getCreateConnectorFn = ({ connectorId, wallet, preventWagmiSyncFromCalling
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const accounts = (_b = (yield ((_a = wallet.connector) === null || _a === void 0 ? void 0 : _a.getConnectedAccounts()))) !== null && _b !== void 0 ? _b : [];
-            return accounts.length > 0;
+            return accounts.includes(wallet.address);
         });
     },
     name: 'Dynamic',
-    onAccountsChanged(accounts) {
-        config.emitter.emit('change', {
-            accounts: [getAddress(accounts[0])],
-        });
+    onAccountsChanged(_) {
+        // this changes the active account on wagmi, but we don't want to do that
+        // we want the active account to always match the primary wallet
+        // so we should not emit this event on the wagmi config
     },
     onChainChanged(chainId) {
         config.emitter.emit('change', {

package/src/lib/DynamicWagmiConnector.js

@@ -1,26 +1,27 @@
 'use client'
 import { jsx } from 'react/jsx-runtime';
-import { useRef, useMemo, useEffect } from 'react';
+import { useMemo, useEffect } from 'react';
 import { useConfig } from 'wagmi';
 import { ErrorBoundaryInclude, useDynamicContext, ErrorBoundaryExclude } from '@dynamic-labs/sdk-react-core';
+import { isEthereumWallet } from '@dynamic-labs/ethereum-core';
 import { getCreateConnectorFn } from './Connector.js';
 import { SyncDynamicWagmi } from './SyncDynamicWagmi.js';
 import { useChainMismatchLogger } from './useChainMismatchLogger.js';
 import { useConnectorId } from './hooks/useConnectorId/useConnectorId.js';
 
-const DynamicWagmiConnector = ({ suppressChainMismatchError = false, children, }) => (jsx(ErrorBoundaryInclude, { children: jsx(DynamicWagmiConnectorInner, { suppressChainMismatchError: true, children: children }) }));
-const isEvmWallet = (wallet) => (wallet === null || wallet === void 0 ? void 0 : wallet.connector.connectedChain) === 'EVM';
+const DynamicWagmiConnector = ({ suppressChainMismatchError = false, children, }) => (jsx(ErrorBoundaryInclude, { children: jsx(DynamicWagmiConnectorInner, { suppressChainMismatchError: suppressChainMismatchError, children: children }) }));
+const getEvmWallet = (wallet) => {
+    if (!wallet || !isEthereumWallet(wallet)) {
+        return null;
+    }
+    return wallet;
+};
 const DynamicWagmiConnectorInner = ({ suppressChainMismatchError = false, children }) => {
     const config = useConfig();
-    const { handleLogOut, primaryWallet } = useDynamicContext();
+    const { primaryWallet } = useDynamicContext();
     useChainMismatchLogger({ throwOnMismatch: !suppressChainMismatchError });
-    const evmWallet = isEvmWallet(primaryWallet) ? primaryWallet : null;
+    const evmWallet = getEvmWallet(primaryWallet);
     const getConnectorId = useConnectorId();
-    /**
-     * This will prevent the wagmi Connector from calling handleLogOut when we are the ones calling disconnect
-     * as a result of a handleLogOut call (see SyncDynamicWagmi), but will preserve the existing behavior for customers.
-     */
-    const preventWagmiSyncFromCallingLogout = useRef(false);
     const connector = useMemo(() => {
         if (!evmWallet) {
             return;
@@ -28,11 +29,9 @@ const DynamicWagmiConnectorInner = ({ suppressChainMismatchError = false, childr
         const connectorId = getConnectorId(evmWallet.connector);
         return config._internal.connectors.setup(getCreateConnectorFn({
             connectorId,
-            handleLogOut,
-            preventWagmiSyncFromCallingLogout,
             wallet: evmWallet,
         }));
-    }, [config._internal.connectors, getConnectorId, handleLogOut, evmWallet]);
+    }, [config._internal.connectors, getConnectorId, evmWallet]);
     /**
      * Updating the wagmi config must be done in a useEffect because
      * when setting the public client and connectors, wagmi will fire
@@ -43,7 +42,7 @@ const DynamicWagmiConnectorInner = ({ suppressChainMismatchError = false, childr
     useEffect(() => {
         config._internal.connectors.setState(connector ? [connector] : []);
     }, [config._internal.connectors, connector]);
-    return (jsx(SyncDynamicWagmi, { connector: connector, preventWagmiSyncFromCallingLogout: preventWagmiSyncFromCallingLogout, wallet: evmWallet, children: jsx(ErrorBoundaryExclude, { children: children }) }));
+    return (jsx(SyncDynamicWagmi, { connector: connector, wallet: evmWallet, children: jsx(ErrorBoundaryExclude, { children: children }) }));
 };
 
 export { DynamicWagmiConnector, DynamicWagmiConnectorInner };

package/src/lib/SyncDynamicWagmi.d.ts

@@ -1,9 +1,8 @@
-import React, { MutableRefObject } from 'react';
+import React from 'react';
 import { Connector } from 'wagmi';
 import { Wallet } from '@dynamic-labs/sdk-react-core';
 export type SyncDynamicWagmiProps = React.PropsWithChildren<{
     connector: Connector | undefined;
     wallet: Wallet | null;
-    preventWagmiSyncFromCallingLogout: MutableRefObject<boolean>;
 }>;
-export declare const SyncDynamicWagmi: ({ children, connector, wallet, preventWagmiSyncFromCallingLogout, }: SyncDynamicWagmiProps) => JSX.Element;
+export declare const SyncDynamicWagmi: ({ children, connector, wallet, }: SyncDynamicWagmiProps) => JSX.Element;

package/src/lib/SyncDynamicWagmi.js

@@ -4,43 +4,55 @@ import { jsx, Fragment } from 'react/jsx-runtime';
 import { useRef, useCallback, useEffect } from 'react';
 import { useConfig, useConnect, useDisconnect } from 'wagmi';
 import { useWalletConnectorEvent } from '@dynamic-labs/sdk-react-core';
+import { logger } from '@dynamic-labs/wallet-connector-core';
 
-const SyncDynamicWagmi = ({ children, connector, wallet, preventWagmiSyncFromCallingLogout, }) => {
+const SyncDynamicWagmi = ({ children, connector, wallet, }) => {
     const { state: { status: clientStatus }, } = useConfig();
     const { connect } = useConnect();
     const { disconnect } = useDisconnect();
-    const lastConnectedConnectorId = useRef(undefined);
-    const hasPreviousConnection = Boolean(lastConnectedConnectorId.current);
+    const lastConnectedWalletId = useRef(undefined);
+    const hasPreviousConnection = Boolean(lastConnectedWalletId.current);
+    const disconnectWagmi = useCallback(() => {
+        logger.debug('[SyncDynamicWagmi] disconnecting wagmi - previous status: ', clientStatus);
+        if (clientStatus === 'disconnected') {
+            return;
+        }
+        disconnect();
+        lastConnectedWalletId.current = undefined;
+    }, [disconnect, clientStatus]);
+    const connectWagmi = useCallback((connector, newId, forceConnect) => {
+        logger.debug('[SyncDynamicWagmi] connecting wagmi - previous status: ', clientStatus);
+        if (clientStatus !== 'disconnected' && !forceConnect) {
+            return;
+        }
+        lastConnectedWalletId.current = newId;
+        connect({ connector });
+    }, [connect, clientStatus]);
     const sync = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
-        const isConnected = (_a = (yield (wallet === null || wallet === void 0 ? void 0 : wallet.isConnected()))) !== null && _a !== void 0 ? _a : false;
-        /**
-         * Connects to Wagmi when a connector is available and
-         * the connector has changed since the last connection
-         */
-        if (isConnected &&
-            connector &&
-            (connector === null || connector === void 0 ? void 0 : connector.id) !== lastConnectedConnectorId.current) {
-            lastConnectedConnectorId.current = connector.id;
-            connect({ connector });
+        // if there's no connector, disconnect wagmi
+        if (!connector || !(wallet === null || wallet === void 0 ? void 0 : wallet.address)) {
+            disconnectWagmi();
+            return;
+        }
+        const newId = `${connector.id}-${wallet.address}`;
+        // if the connector hasn't changed since the last connection, do nothing
+        if (newId === lastConnectedWalletId.current) {
             return;
         }
-        if (!isConnected && hasPreviousConnection) {
-            /**
-             * This will prevent the Connector from calling handleLogOut when we are the ones calling disconnect,
-             * but will preserve the existing behavior for customers who use useDisconnect directly.
-             */
-            preventWagmiSyncFromCallingLogout.current = true;
-            disconnect();
-            lastConnectedConnectorId.current = undefined;
+        // if has a previous connection, disconnect wagmi
+        if (hasPreviousConnection) {
+            disconnectWagmi();
         }
+        // and then (re)connect wagmi
+        // force reconnect if has disconnected in the preivous step
+        // in case the clientStatus takes a while to update
+        connectWagmi(connector, newId, hasPreviousConnection);
     }), [
-        connect,
+        connectWagmi,
         connector,
-        disconnect,
+        disconnectWagmi,
         hasPreviousConnection,
-        preventWagmiSyncFromCallingLogout,
-        wallet,
+        wallet === null || wallet === void 0 ? void 0 : wallet.address,
     ]);
     // this is for handling the scenario where the user unlocks the wallet,
     // as well as changes to a linked wallet