@dynamic-labs/ethereum 4.0.0-alpha.3 → 4.0.0-alpha.31

package/src/metaMask/MetaMaskConnector.js

@@ -0,0 +1,395 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { MetaMaskSDK } from '@metamask/sdk';
+import { createWalletClient, custom, isHex, toHex } from 'viem';
+import { EthereumWalletConnector, getOrMapViemChain } from '@dynamic-labs/ethereum-core';
+import { eventListenerHandlers } from '@dynamic-labs/wallet-connector-core';
+import { createEventTimeline, PlatformService, isMobile, retryableFn } from '@dynamic-labs/utils';
+import { getWalletBookWallet, findWalletBookWallet } from '@dynamic-labs/wallet-book';
+import { logger } from '../utils/logger.js';
+import { EthProviderHelper } from '../ethProviderHelper.js';
+import { createMetaMaskSDKDisplayUriState } from './utils/createMetaMaskSDKDisplayUriState.js';
+import { waitForConnection } from './utils/waitForConnection.js';
+import { isPendingWalletRequestPermissionError } from './utils/isPendingWalletRequestPermissionError.js';
+
+/**
+ * The MetaMask SDK must be initialized only once, so we store the instance
+ * in these variables to avoid initializing it multiple times
+ */
+let _metaMaskSDK = null;
+let _metaMaskSDKDisplayUriState = null;
+const eventTimeline = createEventTimeline();
+class MetaMaskConnector extends EthereumWalletConnector {
+    constructor(props) {
+        super(props);
+        this.name = 'MetaMask';
+        this.overrideKey = 'metamask';
+        this.canConnectViaQrCode = true;
+        this.isInAppBrowser = false;
+        this.appName = props.appName;
+        this.appLogoUrl = props.appLogoUrl;
+        /**
+         * The isInAppBrowser must be calculated before initializing the MetaMask SDK.
+         *
+         * The isInAppBrowser is calculated by checking if the window provider is installed
+         * in the browser and if it is running on a mobile device.
+         *
+         * But the MetaMask SDK will inject its own provider to the window if not provider is injected.
+         * This means the MetaMask SDK can interfere with the isInAppBrowser calculation.
+         *
+         * So we need to calculate the isInAppBrowser before initializing the MetaMask SDK
+         * to prevent a false negative
+         */
+        this.isInAppBrowser = this.getIsInAppBrowser();
+        if (!_metaMaskSDK) {
+            this.createMetaMaskSDK();
+        }
+    }
+    getSupportedNetworks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.evmNetworks.map((network) => network.chainId.toString());
+        });
+    }
+    get ethProviderHelper() {
+        return new EthProviderHelper(getWalletBookWallet(this.walletBook, this.key));
+    }
+    get metaMaskSDK() {
+        if (!_metaMaskSDK)
+            throw new Error('MetaMaskSDK not initialized');
+        return _metaMaskSDK;
+    }
+    set metaMaskSDK(metaMaskSDK) {
+        _metaMaskSDK = metaMaskSDK;
+    }
+    get metaMaskSDKDisplayUriState() {
+        if (!_metaMaskSDKDisplayUriState)
+            throw new Error('MetaMaskSDKDisplayUriState not initialized');
+        return _metaMaskSDKDisplayUriState;
+    }
+    createMetaMaskSDK() {
+        const dappMetadata = {
+            iconUrl: this.appLogoUrl,
+            name: this.appName,
+            url: PlatformService.getOrigin(),
+        };
+        _metaMaskSDK = new MetaMaskSDK({
+            _source: 'dynamic-labs',
+            checkInstallationImmediately: true,
+            dappMetadata,
+            enableAnalytics: true,
+            extensionOnly: this.isInstalledOnBrowser(),
+            headless: true,
+            openDeeplink: PlatformService.openURL,
+            preferDesktop: !isMobile(),
+            readonlyRPCMap: getReadonlyRPCMap(this.evmNetworkRpcMap()),
+            useDeeplink: true,
+        });
+        _metaMaskSDKDisplayUriState =
+            createMetaMaskSDKDisplayUriState(_metaMaskSDK);
+    }
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            eventTimeline.postEvent('disconnect');
+            /**
+             * The MetaMask SDK must be terminated and reinitialized on mobile
+             * to prevent deeplinks not working
+             */
+            if (isMobile()) {
+                return this.metaMaskSDK.terminate().then(() => {
+                    _metaMaskSDK = null;
+                    _metaMaskSDKDisplayUriState = null;
+                    return this.createMetaMaskSDK();
+                });
+            }
+            /**
+             * Just terminate the SDK on desktop
+             */
+            return this.metaMaskSDK.terminate();
+        });
+    }
+    getAddress(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                var _a, _b, _c, _d;
+                // QR Code flow
+                if (!isMobile() && Boolean(opts === null || opts === void 0 ? void 0 : opts.onDisplayUri)) {
+                    this.metaMaskSDKDisplayUriState
+                        .consumeDisplayUri()
+                        .then((displayUri) => {
+                        var _a;
+                        if (!displayUri) {
+                            reject(new Error('MetaMask display uri not found'));
+                            return;
+                        }
+                        (_a = opts === null || opts === void 0 ? void 0 : opts.onDisplayUri) === null || _a === void 0 ? void 0 : _a.call(opts, displayUri);
+                    });
+                }
+                // Deep link to MetaMask app in-app browser
+                if (this.shouldDeepLinkToMetaMaskInAppBrowser() &&
+                    ((_b = (_a = this.wallet) === null || _a === void 0 ? void 0 : _a.mobile) === null || _b === void 0 ? void 0 : _b.inAppBrowser)) {
+                    // Redirect to the in-app browser and append the current url
+                    window.location.href = `${(_d = (_c = this.wallet) === null || _c === void 0 ? void 0 : _c.mobile) === null || _d === void 0 ? void 0 : _d.inAppBrowser}/${window.location.href}`;
+                    resolve(undefined);
+                    return;
+                }
+                // Connect to MetaMask
+                this.getConnectedAccountsSafely().then((initialConnectedAccounts) => __awaiter(this, void 0, void 0, function* () {
+                    if (initialConnectedAccounts.length) {
+                        resolve(initialConnectedAccounts[0]);
+                        return;
+                    }
+                    try {
+                        yield this.metaMaskSDK.connect();
+                    }
+                    catch (error) {
+                        const isRequestPendingError = isPendingWalletRequestPermissionError(error);
+                        if (!isRequestPendingError) {
+                            throw error;
+                        }
+                        else {
+                            yield waitForConnection(this.getProvider());
+                        }
+                    }
+                    const accounts = yield this.getConnectedAccounts();
+                    resolve(accounts[0]);
+                }));
+            });
+        });
+    }
+    getConnectedAccountsSafely() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connectedAccounts = yield this.getConnectedAccounts();
+                return connectedAccounts;
+            }
+            catch (err) {
+                logger.error(err);
+                return [];
+            }
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Wait for for MetaMask SDK to initialize
+            yield this.metaMaskSDK.sdkInitPromise;
+            const provider = this.getProvider();
+            if (!provider) {
+                return [];
+            }
+            /**
+             * The eth_accounts method can hang on mobile devices when
+             * the MetaMask SDK has not connected yet. So we use a retryable
+             * to ensure the timeout will be respected
+             */
+            const accounts = yield retryableFn(() => provider.request({
+                method: 'eth_accounts',
+                params: [],
+            }), {
+                fallbackValue: [],
+                timeoutMs: 1000,
+            });
+            if (!(accounts === null || accounts === void 0 ? void 0 : accounts.length)) {
+                return [];
+            }
+            return accounts;
+        });
+    }
+    signMessage(messageToSign, withAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.metaMaskSDK.sdkInitPromise;
+            /**
+             * Should wait for the window to be focused on mobile
+             * to account for the user moving between the MetaMaskApp
+             * and the browser
+             */
+            const windowFocusPromiseForMobile = !this.isInAppBrowser && isMobile()
+                ? waitForFocusWindowEvent()
+                : Promise.resolve();
+            const provider = this.getProvider();
+            if (!provider) {
+                return undefined;
+            }
+            const [selectedAddress] = yield this.getConnectedAccounts();
+            const effectiveAddress = withAddress !== null && withAddress !== void 0 ? withAddress : selectedAddress;
+            if (!effectiveAddress) {
+                return undefined;
+            }
+            const walletClient = this.getWalletClientForAddress(effectiveAddress);
+            if (!walletClient)
+                return undefined;
+            const signature = yield walletClient.signMessage({
+                message: messageToSign,
+            });
+            yield windowFocusPromiseForMobile;
+            return signature;
+        });
+    }
+    chooseAccountsToConnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+    getWalletClient(chainId) {
+        const provider = this.getProvider();
+        if (!provider) {
+            return undefined;
+        }
+        const selectedAddress = provider.getSelectedAddress();
+        return this.getWalletClientForAddress(selectedAddress || undefined, chainId);
+    }
+    get rdns() {
+        const { rdns } = this.metadata;
+        if (!rdns) {
+            throw new Error('rdns not found in metadata');
+        }
+        return rdns;
+    }
+    isInstalledOnBrowser() {
+        var _a;
+        const metaMaskEip6963Provider = (_a = this.ethProviderHelper) === null || _a === void 0 ? void 0 : _a.eip6963ProviderLookup(this.rdns);
+        const isInstalled = Boolean(metaMaskEip6963Provider);
+        return isInstalled;
+    }
+    setupEventListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.metaMaskSDK.sdkInitPromise;
+            const metaMaskProvider = this.getProvider();
+            if (!metaMaskProvider) {
+                return;
+            }
+            const { handleAccountChange, handleChainChange, handleDisconnect } = eventListenerHandlers(this);
+            const handleAccountsChangedFromMetaMask = (accounts) => {
+                /**
+                 * MetaMask emits an account changed event when the wallet is disconnected
+                 * so we ignore the accountsChanged event if the disconnect event was recent
+                 */
+                if (eventTimeline.isEventRecent('disconnect', 1000)) {
+                    return;
+                }
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                handleAccountChange(accounts);
+            };
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            metaMaskProvider.on('accountsChanged', handleAccountsChangedFromMetaMask);
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            metaMaskProvider.on('chainChanged', handleChainChange);
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            metaMaskProvider.on('disconnect', handleDisconnect);
+            this.teardownEventListeners = () => {
+                metaMaskProvider.off('accountsChanged', handleAccountsChangedFromMetaMask);
+                metaMaskProvider.off('chainChanged', handleChainChange);
+                metaMaskProvider.off('disconnect', handleDisconnect);
+            };
+        });
+    }
+    /**
+     * This override is necessary to wait for the MetaMask SDK to initialize
+     * before calling the super method. Otherwise, the super method may fail
+     * to fetch the provider
+     */
+    getNetwork() {
+        const _super = Object.create(null, {
+            getNetwork: { get: () => super.getNetwork }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.metaMaskSDK.sdkInitPromise;
+            const net = yield _super.getNetwork.call(this);
+            return net;
+        });
+    }
+    // Utils
+    getProvider() {
+        var _a;
+        return ((_a = this.metaMaskSDK.getProvider()) !== null && _a !== void 0 ? _a : this.metaMaskSDK.getMobileProvider());
+    }
+    evmNetworkByChainId(chainId) {
+        return this.evmNetworks.find((network) => network.chainId === chainId);
+    }
+    getWalletClientForAddress(address, chainId) {
+        var _a, _b;
+        const provider = this.getProvider();
+        if (!provider) {
+            return undefined;
+        }
+        const effectiveChainId = (_b = (_a = this.toInt(chainId)) !== null && _a !== void 0 ? _a : this.getCurrentChainId()) !== null && _b !== void 0 ? _b : '1';
+        const network = this.evmNetworkByChainId(effectiveChainId);
+        return createWalletClient({
+            account: address,
+            chain: network ? getOrMapViemChain(network) : this.getActiveChain(),
+            transport: custom(provider),
+        });
+    }
+    toInt(chainId) {
+        if (!chainId)
+            return undefined;
+        try {
+            return parseInt(chainId);
+        }
+        catch (err) {
+            logger.debug(err);
+            return undefined;
+        }
+    }
+    getCurrentChainId() {
+        const provider = this.getProvider();
+        if (!provider) {
+            return undefined;
+        }
+        const chainId = provider.getChainId();
+        if (isHex(chainId)) {
+            return parseInt(chainId);
+        }
+        return chainId;
+    }
+    /**
+     * Checks if the current environment is the MetaMask in-app browser
+     * by checking if the MetaMask provider is installed in the window object
+     * on a mobile device
+     */
+    getIsInAppBrowser() {
+        var _a, _b;
+        if (!isMobile())
+            return false;
+        const provider = ((_a = this.ethProviderHelper) === null || _a === void 0 ? void 0 : _a.eip6963ProviderLookup(this.rdns)) ||
+            ((_b = this.ethProviderHelper) === null || _b === void 0 ? void 0 : _b.getInjectedProvider());
+        return Boolean(provider);
+    }
+    shouldDeepLinkToMetaMaskInAppBrowser() {
+        var _a;
+        // Not in an in-app browser
+        if (this.isInAppBrowser)
+            return false;
+        // Not a mobile device
+        if (!isMobile())
+            return false;
+        // SDK is configured to use the in-app browser
+        if (this.mobileExperience !== 'in-app-browser')
+            return false;
+        const isAppBrowserLinkPresent = ((_a = this.wallet) === null || _a === void 0 ? void 0 : _a.mobile) && this.wallet.mobile.inAppBrowser;
+        // Wallet has an in-app browser link
+        if (!isAppBrowserLinkPresent)
+            return false;
+        return true;
+    }
+    /**
+     * Get wallet book wallet information
+     */
+    get wallet() {
+        return findWalletBookWallet(this.walletBook, this.key);
+    }
+}
+// Utils
+const getReadonlyRPCMap = (evmNetworkRpcMap) => Object.keys(evmNetworkRpcMap).reduce((acc, chainId) => (Object.assign(Object.assign({}, acc), { [toHex(parseInt(chainId))]: evmNetworkRpcMap[chainId] })), {});
+/**
+ * Waits for the focus page event and await for an extra second
+ * This is necessary to ensure the verify call will succeed
+ */
+const waitForFocusWindowEvent = () => new Promise((resolve) => {
+    window.addEventListener('focus', resolve);
+}).then(() => new Promise((resolve) => setTimeout(resolve, 1000)));
+
+export { MetaMaskConnector };

package/src/metaMask/utils/createMetaMaskSDKDisplayUriState.cjs

@@ -0,0 +1,58 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+/**
+ * Listens for the `display_uri` event emitted by the MetaMask SDK.
+ *
+ * The `display_uri` event is triggered during SDK initialization or when the `connect` method is called.
+ * Calling `terminate` in the MetaMask SDK resets the connection, and a new `display_uri` will only be emitted
+ * when `connect` is called again.
+ *
+ * This function manages the new `display_uri` received from these events.
+ */
+const createMetaMaskSDKDisplayUriState = (metaMaskSDK) => {
+    let lastKnownMetaMaskDeepLinkUri = null;
+    let displayUri = null;
+    metaMaskSDK.on('display_uri', (latestDisplayUri) => {
+        if (lastKnownMetaMaskDeepLinkUri !== latestDisplayUri) {
+            lastKnownMetaMaskDeepLinkUri = latestDisplayUri;
+            displayUri = latestDisplayUri.trim();
+        }
+    });
+    return {
+        consumeDisplayUri: () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+            const currentDisplayUri = displayUri;
+            if (currentDisplayUri) {
+                displayUri = null;
+                return currentDisplayUri;
+            }
+            return new Promise((resolve) => {
+                let timeoutId = null;
+                let intervalId = null;
+                const cleanUp = () => {
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    if (intervalId)
+                        clearInterval(intervalId);
+                };
+                timeoutId = setTimeout(() => {
+                    cleanUp();
+                    resolve(undefined);
+                }, 1000);
+                intervalId = setInterval(() => {
+                    if (displayUri) {
+                        cleanUp();
+                        resolve(displayUri);
+                        displayUri = null;
+                    }
+                }, 10);
+            });
+        }),
+    };
+};
+
+exports.createMetaMaskSDKDisplayUriState = createMetaMaskSDKDisplayUriState;

package/src/metaMask/utils/createMetaMaskSDKDisplayUriState.d.ts

@@ -0,0 +1,14 @@
+import { MetaMaskSDK } from '@metamask/sdk';
+export type MetaMaskSDKDisplayUriState = {
+    consumeDisplayUri: () => Promise<string | undefined>;
+};
+/**
+ * Listens for the `display_uri` event emitted by the MetaMask SDK.
+ *
+ * The `display_uri` event is triggered during SDK initialization or when the `connect` method is called.
+ * Calling `terminate` in the MetaMask SDK resets the connection, and a new `display_uri` will only be emitted
+ * when `connect` is called again.
+ *
+ * This function manages the new `display_uri` received from these events.
+ */
+export declare const createMetaMaskSDKDisplayUriState: (metaMaskSDK: MetaMaskSDK) => MetaMaskSDKDisplayUriState;

package/src/metaMask/utils/createMetaMaskSDKDisplayUriState.js

@@ -0,0 +1,54 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+
+/**
+ * Listens for the `display_uri` event emitted by the MetaMask SDK.
+ *
+ * The `display_uri` event is triggered during SDK initialization or when the `connect` method is called.
+ * Calling `terminate` in the MetaMask SDK resets the connection, and a new `display_uri` will only be emitted
+ * when `connect` is called again.
+ *
+ * This function manages the new `display_uri` received from these events.
+ */
+const createMetaMaskSDKDisplayUriState = (metaMaskSDK) => {
+    let lastKnownMetaMaskDeepLinkUri = null;
+    let displayUri = null;
+    metaMaskSDK.on('display_uri', (latestDisplayUri) => {
+        if (lastKnownMetaMaskDeepLinkUri !== latestDisplayUri) {
+            lastKnownMetaMaskDeepLinkUri = latestDisplayUri;
+            displayUri = latestDisplayUri.trim();
+        }
+    });
+    return {
+        consumeDisplayUri: () => __awaiter(void 0, void 0, void 0, function* () {
+            const currentDisplayUri = displayUri;
+            if (currentDisplayUri) {
+                displayUri = null;
+                return currentDisplayUri;
+            }
+            return new Promise((resolve) => {
+                let timeoutId = null;
+                let intervalId = null;
+                const cleanUp = () => {
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    if (intervalId)
+                        clearInterval(intervalId);
+                };
+                timeoutId = setTimeout(() => {
+                    cleanUp();
+                    resolve(undefined);
+                }, 1000);
+                intervalId = setInterval(() => {
+                    if (displayUri) {
+                        cleanUp();
+                        resolve(displayUri);
+                        displayUri = null;
+                    }
+                }, 10);
+            });
+        }),
+    };
+};
+
+export { createMetaMaskSDKDisplayUriState };

package/src/metaMask/utils/isPendingWalletRequestPermissionError.cjs

@@ -0,0 +1,11 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const isPendingWalletRequestPermissionError = (error) => typeof error === 'object' &&
+    error !== null &&
+    'message' in error &&
+    error.message.includes("Request of type 'wallet_requestPermissions' already pending for origin");
+
+exports.isPendingWalletRequestPermissionError = isPendingWalletRequestPermissionError;

package/src/metaMask/utils/isPendingWalletRequestPermissionError.d.ts

@@ -0,0 +1 @@
+export declare const isPendingWalletRequestPermissionError: (error: any) => any;

package/src/metaMask/utils/isPendingWalletRequestPermissionError.js

@@ -0,0 +1,7 @@
+'use client'
+const isPendingWalletRequestPermissionError = (error) => typeof error === 'object' &&
+    error !== null &&
+    'message' in error &&
+    error.message.includes("Request of type 'wallet_requestPermissions' already pending for origin");
+
+export { isPendingWalletRequestPermissionError };

package/src/metaMask/utils/waitForConnection.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const waitForConnection = (provider) => new Promise((resolve) => {
+    provider.once('connect', () => resolve());
+});
+
+exports.waitForConnection = waitForConnection;

package/src/metaMask/utils/waitForConnection.d.ts

@@ -0,0 +1,2 @@
+import { SDKProvider } from '@metamask/sdk';
+export declare const waitForConnection: (provider: SDKProvider) => Promise<void>;

package/src/metaMask/utils/waitForConnection.js

@@ -0,0 +1,6 @@
+'use client'
+const waitForConnection = (provider) => new Promise((resolve) => {
+    provider.once('connect', () => resolve());
+});
+
+export { waitForConnection };

package/src/types.d.ts

@@ -1,6 +1,4 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { EventEmitter } from 'stream';
+import { type EventEmitter } from 'eventemitter3';
 import { PublicClient } from 'viem';
 import { ProviderCondition } from '@dynamic-labs/wallet-connector-core';
 declare global {

package/src/utils/logger.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger$1 = require('@dynamic-labs/logger');
+
+const logger = new logger$1.Logger('@dynamic-labs/ethereum');
+
+exports.logger = logger;

package/src/utils/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '@dynamic-labs/logger';
+export declare const logger: Logger;

package/src/utils/logger.js

@@ -0,0 +1,6 @@
+'use client'
+import { Logger } from '@dynamic-labs/logger';
+
+const logger = new Logger('@dynamic-labs/ethereum');
+
+export { logger };

package/src/walletConnect/walletConnect.cjs

@@ -23,12 +23,10 @@ const sessionTopicKey = (walletName) => `dynamic-wc2-session-topic-${walletName}
 const swicthedNetworkKey = (walletName) => `dynamic-wc2-switched-network-${walletName}`;
 const currentChainKey = (walletName) => `dynamic-wc2-current-chain-${walletName}`;
 const ee = new EventEmitter__default["default"]();
-class WalletConnect extends ethereumCore.EthWalletConnector {
+class WalletConnect extends ethereumCore.EthereumWalletConnector {
     constructor(opts) {
         var _a;
         super(opts);
-        this.supportedChains = ['EVM', 'ETH'];
-        this.connectedChain = 'EVM';
         this.isInitialized = false;
         this.canConnectViaQrCode = true;
         this.isWalletConnect = true;

package/src/walletConnect/walletConnect.d.ts

@@ -1,17 +1,15 @@
 import type { SessionTypes } from '@walletconnect/types';
 import { WalletClient, Account, Transport, Chain as ViemChain } from 'viem';
-import { Chain, GetAddressOpts, DeepLinkVariant, IWalletConnectConnector } from '@dynamic-labs/wallet-connector-core';
+import { GetAddressOpts, DeepLinkVariant, IWalletConnectConnector } from '@dynamic-labs/wallet-connector-core';
 import { EvmNetwork } from '@dynamic-labs/types';
-import { EthWalletConnector, EthWalletConnectorOpts } from '@dynamic-labs/ethereum-core';
-export type WalletConnectOpts = EthWalletConnectorOpts & {
+import { EthereumWalletConnector, EthereumWalletConnectorOpts } from '@dynamic-labs/ethereum-core';
+export type WalletConnectOpts = EthereumWalletConnectorOpts & {
     projectId?: string;
     walletName: string;
     deepLinkPreference?: DeepLinkVariant;
     walletConnectPreferredChains?: `eip155:${number}`[];
 };
-export declare class WalletConnect extends EthWalletConnector implements IWalletConnectConnector {
-    supportedChains: Chain[];
-    connectedChain: Chain;
+export declare class WalletConnect extends EthereumWalletConnector implements IWalletConnectConnector {
     name: string;
     session: SessionTypes.Struct | undefined;
     isInitialized: boolean;

package/src/walletConnect/walletConnect.js

@@ -6,7 +6,7 @@ import { createWalletClient, custom } from 'viem';
 import { logger, performPlatformSpecificConnectionMethod, getDeepLink } from '@dynamic-labs/wallet-connector-core';
 import { getWalletBookWallet } from '@dynamic-labs/wallet-book';
 import { DynamicError, sleep, isMobile } from '@dynamic-labs/utils';
-import { EthWalletConnector, chainsMap } from '@dynamic-labs/ethereum-core';
+import { EthereumWalletConnector, chainsMap } from '@dynamic-labs/ethereum-core';
 import { parseIntSafe } from '../utils/parseIntSafe.js';
 
 const activeAccountKey = (walletName) => `dynamic-wc2-active-account-${walletName}`;
@@ -14,12 +14,10 @@ const sessionTopicKey = (walletName) => `dynamic-wc2-session-topic-${walletName}
 const swicthedNetworkKey = (walletName) => `dynamic-wc2-switched-network-${walletName}`;
 const currentChainKey = (walletName) => `dynamic-wc2-current-chain-${walletName}`;
 const ee = new EventEmitter();
-class WalletConnect extends EthWalletConnector {
+class WalletConnect extends EthereumWalletConnector {
     constructor(opts) {
         var _a;
         super(opts);
-        this.supportedChains = ['EVM', 'ETH'];
-        this.connectedChain = 'EVM';
         this.isInitialized = false;
         this.canConnectViaQrCode = true;
         this.isWalletConnect = true;