@dynamic-labs/ethereum 4.9.1 → 4.9.2

package/src/walletConnect/WalletConnectConnector/WalletConnectConnector.js

@@ -0,0 +1,288 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { createWalletClient, custom } from 'viem';
+import { toAccount } from 'viem/accounts';
+import { EthereumWalletConnector, chainsMap } from '@dynamic-labs/ethereum-core';
+import { StorageService, parseIntSafe, DynamicError, isMobile, PlatformService } from '@dynamic-labs/utils';
+import { logger, getDeepLink } from '@dynamic-labs/wallet-connector-core';
+import { normalizeRpcError } from '../../utils/normalizeRpcError/normalizeRpcError.js';
+import { WalletConnectProvider } from '../WalletConnectProvider/WalletConnectProvider.js';
+
+const WC_CURRENT_CHAIN_KEY = 'dynamic-wc2-current-chain';
+class WalletConnectConnector extends EthereumWalletConnector {
+    constructor(opts) {
+        super(opts);
+        this.canConnectViaQrCode = true;
+        this.isWalletConnect = true;
+        this.name = opts.walletName;
+        this.deepLinkPreference = opts.deepLinkPreference || 'native';
+        const storedChainId = StorageService.getItem(WC_CURRENT_CHAIN_KEY);
+        if (storedChainId) {
+            this.currentChainId = parseIntSafe(storedChainId);
+        }
+        if (!opts.projectId) {
+            throw new DynamicError('WalletConnect project ID is required');
+        }
+        // set provider props generic to all wallets
+        WalletConnectProvider.projectId = opts.projectId;
+        WalletConnectProvider.enabledNetworks = opts.evmNetworks;
+        WalletConnectProvider.preferredChains =
+            opts.walletConnectPreferredChains || [];
+        WalletConnectProvider.evmNetworkRpcMap = this.evmNetworkRpcMap();
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] init called', {
+                isInitialized: WalletConnectProvider.isInitialized,
+                isInitializing: WalletConnectProvider.isInitializing,
+            });
+            // we should only init the provider once as soon as possible
+            // the connection is established when a wallet is selected (with getAddress)
+            if (WalletConnectProvider.isInitialized ||
+                WalletConnectProvider.isInitializing) {
+                logger.debug('[WalletConnect] init - already initialized or initializing - skipping');
+                return;
+            }
+            logger.debug('[WalletConnect] init');
+            this.walletConnectorEventsEmitter.emit('connectorInitStarted', 'walletconnect');
+            try {
+                yield WalletConnectProvider.init();
+            }
+            catch (error) {
+                logger.error('[WalletConnect] init - error', error);
+                throw new DynamicError('WalletConnectProvider failed to initialize');
+            }
+            this.setupWCEventListeners();
+            this.walletConnectorEventsEmitter.emit('connectorInitCompleted', 'walletconnect');
+        });
+    }
+    setupWCEventListeners() {
+        logger.debug('[WalletConnect] setupWCEventListeners');
+        WalletConnectProvider.teardownEventListeners();
+        WalletConnectProvider.setupEventListeners({
+            onAccountChanged: (account) => {
+                logger.debug('[WalletConnect] onAccountChanged', { account });
+                this.emit('accountChange', { accounts: [account] });
+            },
+            onChainChanged: (chainId) => {
+                logger.debug('[WalletConnect] onChainChange', { chainId });
+                if (chainId === this.currentChainId) {
+                    logger.debug(`[WalletConnect] onChainChange - ignoring chainChanged event with same chain id as current chain id: ${chainId}`);
+                    return;
+                }
+                this.currentChainId = chainId;
+                this.emit('chainChange', { chain: String(chainId) });
+            },
+            onDisconnect: () => {
+                logger.debug('[WalletConnect] onDisconnect');
+                this.endSession();
+                this.emit('disconnect');
+            },
+        });
+    }
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug('[WalletConnect] endSession');
+            this.currentChainId = undefined;
+            yield WalletConnectProvider.disconnect();
+        });
+    }
+    getAddress(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug('[WalletConnect] getAddress', opts);
+            const provider = yield WalletConnectProvider.awaitAndGetProvider();
+            logger.debug('[WalletConnect] getAddress - connecting to WalletConnect', {
+                provider,
+            });
+            const addresses = yield WalletConnectProvider.connect({
+                connectionOpts: opts,
+                deepLinkPreference: this.deepLinkPreference,
+                deepLinks: this.metadata.deepLinks,
+            });
+            logger.debug('[WalletConnect] getAddress - connection result', addresses);
+            const address = addresses === null || addresses === void 0 ? void 0 : addresses[0];
+            return address;
+        });
+    }
+    getWalletClient(chainId) {
+        logger.logVerboseTroubleshootingMessage('[WalletConnect] getWalletClient was called - chainId', chainId);
+        const provider = WalletConnectProvider.getProvider();
+        if (!provider) {
+            logger.debug('[WalletConnect] getWalletClient - provider is not initialized');
+            throw new DynamicError('WalletConnectProvider is not initialized');
+        }
+        const walletClient = createWalletClient({
+            account: this.getActiveAccount(),
+            chain: chainsMap[chainId !== null && chainId !== void 0 ? chainId : String(this.currentChainId)],
+            transport: custom({
+                request: (args) => {
+                    this.deepLinkIfApplicable(args.method);
+                    return provider.request(args).catch(normalizeRpcError);
+                },
+            }),
+        });
+        return walletClient;
+    }
+    deepLinkIfApplicable(method) {
+        const methodsThatRequireDeepLink = [
+            'personal_sign',
+            'eth_sendTransaction',
+            'eth_signTypedData_v4',
+        ];
+        const deepLink = this.getDeepLink();
+        if (isMobile() && deepLink && methodsThatRequireDeepLink.includes(method)) {
+            PlatformService.openURL(deepLink);
+        }
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] signMessage', messageToSign);
+            const activeAccount = this.getActiveAccount();
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] signMessage - activeAccount', activeAccount);
+            if (!activeAccount) {
+                return;
+            }
+            const walletClient = yield this.getWalletClient();
+            return walletClient.signMessage({
+                account: activeAccount,
+                message: messageToSign,
+            });
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const activeAccount = this.getActiveAccount();
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] getConnectedAccounts - activeAccount', activeAccount);
+            return activeAccount ? [activeAccount.address] : [];
+        });
+    }
+    getActiveAccount() {
+        var _a;
+        const provider = WalletConnectProvider.getProvider();
+        const connectedAccount = (_a = provider === null || provider === void 0 ? void 0 : provider.accounts) === null || _a === void 0 ? void 0 : _a[0];
+        logger.logVerboseTroubleshootingMessage('[WalletConnect] getActiveAccount - connectedAccount', connectedAccount);
+        if (!connectedAccount) {
+            return undefined;
+        }
+        return toAccount(connectedAccount);
+    }
+    get currentChainId() {
+        const lsCurrentChain = StorageService.getItem(WC_CURRENT_CHAIN_KEY);
+        try {
+            return lsCurrentChain ? parseIntSafe(lsCurrentChain) : undefined;
+        }
+        catch (e) {
+            logger.debug('[WalletConnect] getCurrentChainId - error', e);
+            return undefined;
+        }
+    }
+    set currentChainId(value) {
+        if (value) {
+            StorageService.setItem(WC_CURRENT_CHAIN_KEY, value.toString());
+        }
+        else {
+            StorageService.removeItem(WC_CURRENT_CHAIN_KEY);
+        }
+    }
+    getActiveChain() {
+        if (!this.currentChainId) {
+            return undefined;
+        }
+        return chainsMap[this.currentChainId];
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] getNetwork');
+            const provider = yield WalletConnectProvider.awaitAndGetProvider();
+            if (provider === null || provider === void 0 ? void 0 : provider.chainId) {
+                const network = provider.chainId;
+                this.currentChainId = network;
+                logger.logVerboseTroubleshootingMessage('[WalletConnect] getNetwork - provider network', network);
+                return network;
+            }
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] getNetwork - no provider found, returning current chain id', {
+                currentChainId: this.currentChainId,
+            });
+            return this.currentChainId;
+        });
+    }
+    providerSwitchNetwork(_a) {
+        const _super = Object.create(null, {
+            providerSwitchNetwork: { get: () => super.providerSwitchNetwork }
+        });
+        return __awaiter(this, arguments, void 0, function* ({ network, }) {
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] providerSwitchNetwork - network', {
+                network,
+                switchNetworkOnlyFromWallet: this.switchNetworkOnlyFromWallet,
+            });
+            const currentNetworkId = yield this.getNetwork();
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] providerSwitchNetwork - currentNetworkId', currentNetworkId);
+            if (currentNetworkId && currentNetworkId === network.chainId) {
+                return;
+            }
+            if (this.switchNetworkOnlyFromWallet) {
+                throw new DynamicError('Network switching is only supported through the wallet');
+            }
+            const walletClient = yield this.getWalletClient();
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] providerSwitchNetwork - will switch network');
+            yield _super.providerSwitchNetwork.call(this, { network, provider: walletClient });
+            this.currentChainId = network.chainId;
+            logger.logVerboseTroubleshootingMessage('[WalletConnect] providerSwitchNetwork - switched network', network.chainId);
+            this.emit('chainChange', { chain: String(network.chainId) });
+        });
+    }
+    supportsNetworkSwitching() {
+        return true;
+    }
+    getSupportedNetworks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const provider = yield WalletConnectProvider.awaitAndGetProvider();
+            if (!(provider === null || provider === void 0 ? void 0 : provider.session)) {
+                return [];
+            }
+            const chains = [];
+            // Some wallet (i.e ZenGo) use namespaces.account to list supported chains
+            // while others use keys within the namespaces object
+            Object.keys(provider === null || provider === void 0 ? void 0 : provider.session.namespaces).forEach((key) => {
+                if (key.startsWith('eip155:')) {
+                    chains.push(key.split(':')[1]);
+                }
+            });
+            (_a = provider === null || provider === void 0 ? void 0 : provider.session.namespaces.eip155) === null || _a === void 0 ? void 0 : _a.accounts.forEach((account) => chains.push(account.split(':')[1]));
+            return chains.length
+                ? chains
+                : this.evmNetworks.map((network) => network.chainId.toString());
+        });
+    }
+    getDeepLink() {
+        var _a;
+        const provider = WalletConnectProvider.getProvider();
+        logger.debug('[WalletConnect] getDeepLink', {
+            hasSession: Boolean(provider === null || provider === void 0 ? void 0 : provider.session),
+            topic: (_a = provider === null || provider === void 0 ? void 0 : provider.session) === null || _a === void 0 ? void 0 : _a.topic,
+            uri: provider === null || provider === void 0 ? void 0 : provider.signer.uri,
+        });
+        if (!(provider === null || provider === void 0 ? void 0 : provider.session)) {
+            return;
+        }
+        const deepLink = getDeepLink({
+            deepLinks: this.metadata.deepLinks,
+            mode: 'regular',
+            preference: this.deepLinkPreference,
+            uri: provider.signer.uri,
+        });
+        logger.logVerboseTroubleshootingMessage('[WalletConnect] getDeepLink - deepLink', deepLink);
+        if (!deepLink) {
+            return;
+        }
+        // we need to include the session topic here because it helps the wallet
+        // auto redirect back to the dapp after signing
+        return `${deepLink}?sessionTopic=${provider.session.topic}`;
+    }
+    getConnectionUri() {
+        return WalletConnectProvider.getConnectionUri();
+    }
+}
+
+export { WalletConnectConnector };

package/src/walletConnect/WalletConnectConnector/index.d.ts

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

package/src/walletConnect/WalletConnectProvider/WalletConnectProvider.cjs

@@ -0,0 +1,212 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var EthereumProvider = require('@walletconnect/ethereum-provider');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var utils = require('@dynamic-labs/utils');
+var logger = require('../../utils/logger.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EthereumProvider__default = /*#__PURE__*/_interopDefaultLegacy(EthereumProvider);
+
+var _a;
+class WalletConnectProvider {
+    constructor() {
+        throw new Error('WalletConnectProvider is not instantiable');
+    }
+    static getMappedChainsByPreferredOrder() {
+        const allChains = _a.enabledNetworks.map((network) => `eip155:${network.chainId}`);
+        const reorderedChains = _a.preferredChains.filter((chain) => allChains.includes(chain));
+        const remainingChains = allChains.filter((chain) => !_a.preferredChains.includes(chain));
+        return [...reorderedChains, ...remainingChains].map((chain) => Number(chain.split(':')[1]));
+    }
+}
+_a = WalletConnectProvider;
+WalletConnectProvider.isInitializing = false;
+WalletConnectProvider.isInitialized = false;
+WalletConnectProvider.enabledNetworks = [];
+WalletConnectProvider.preferredChains = [];
+WalletConnectProvider.evmNetworkRpcMap = {};
+WalletConnectProvider.eventListenersSetup = false;
+WalletConnectProvider.accountChangedHandler = () => { };
+WalletConnectProvider.chainChangedHandler = () => { };
+WalletConnectProvider.disconnectHandler = () => { };
+/**
+ * Initializes the provider. This method should only be called once.
+ * Does not start a connection.
+ */
+WalletConnectProvider.init = (...args_1) => _tslib.__awaiter(void 0, [...args_1], void 0, function* ({ storePrefix = 'dynamic-wc2', } = {}) {
+    logger.logger.debug('[WalletConnectProvider] init', {
+        isInitialized: _a.isInitialized,
+        isInitializing: _a.isInitializing,
+    });
+    if (_a.isInitializing ||
+        _a.isInitialized) {
+        return;
+    }
+    _a.isInitializing = true;
+    logger.logger.debug('[WalletConnectProvider] initializing');
+    _a.providerInitPromise = EthereumProvider__default["default"].init({
+        customStoragePrefix: storePrefix,
+        disableProviderPing: true,
+        optionalChains: _a.getMappedChainsByPreferredOrder(),
+        optionalEvents: ['chainChanged', 'accountsChanged'],
+        optionalMethods: [
+            'eth_chainId',
+            'eth_signTypedData',
+            'eth_signTransaction',
+            'eth_sign',
+            'personal_sign',
+            'eth_sendTransaction',
+            'eth_signTypedData_v4',
+            'wallet_switchEthereumChain',
+            'wallet_addEthereumChain',
+        ],
+        projectId: _a.projectId,
+        rpcMap: _a.evmNetworkRpcMap,
+        showQrModal: false,
+    });
+    _a.provider =
+        yield _a.providerInitPromise;
+    _a.isInitialized = true;
+    _a.isInitializing = false;
+    logger.logger.debug('[WalletConnectProvider] initialized');
+});
+/**
+ * Connects to a wallet. This method should be called whenever a new wallet connection is needed.
+ * If the wallet is already connected when the page is refreshed, this method does not need to be called.
+ */
+WalletConnectProvider.connect = (_b) => _tslib.__awaiter(void 0, [_b], void 0, function* ({ deepLinks, deepLinkPreference, connectionOpts, }) {
+    const handleDisplayURI = (uri) => {
+        var _b;
+        logger.logger.debug('[WalletConnectProvider] handleDisplayURI', uri);
+        _a.connectionUri = uri;
+        walletConnectorCore.performPlatformSpecificConnectionMethod(_a.connectionUri, deepLinks, {
+            onDesktopUri: connectionOpts === null || connectionOpts === void 0 ? void 0 : connectionOpts.onDesktopUri,
+            onDisplayUri: connectionOpts === null || connectionOpts === void 0 ? void 0 : connectionOpts.onDisplayUri,
+        }, deepLinkPreference);
+        logger.logger.debug('[WalletConnectProvider] removing display_uri event listener');
+        (_b = _a.provider) === null || _b === void 0 ? void 0 : _b.off('display_uri', handleDisplayURI);
+    };
+    if (!_a.provider) {
+        logger.logger.error('[WalletConnectProvider] connect - provider is not initialized');
+        throw new utils.DynamicError('WalletConnectProvider is not initialized');
+    }
+    // this is in case the user just cancels the deeplink prompt (i.e. in mobile/Safari)
+    // in this case, the connection is not rejected, so the "enable" promise is just pending
+    // so on retry, we should just use the same uri to handle that promise
+    if (_a.connectionUri) {
+        handleDisplayURI(_a.connectionUri);
+        return;
+    }
+    logger.logger.debug('[WalletConnectProvider] adding display_uri event listener');
+    _a.provider.on('display_uri', handleDisplayURI);
+    try {
+        // enable = connect to the provider
+        const result = yield _a.provider.enable();
+        logger.logger.debug('[WalletConnectProvider] connected to WalletConnect', result);
+        return result;
+    }
+    catch (error) {
+        logger.logger.error('[WalletConnectProvider] Failed to connect to WalletConnect', error);
+        const customError = new utils.DynamicError('Connection rejected. Please try again.');
+        customError.code = 'connection_rejected';
+        throw customError;
+    }
+    finally {
+        // Reset the connection URI after it's been consumed
+        _a.connectionUri = undefined;
+    }
+});
+/**
+ * Disconnects from a wallet. This method should be called whenever we need to disconnect from a wallet.
+ * It will kill the connection, but not the provider.
+ */
+WalletConnectProvider.disconnect = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    if (!_a.provider) {
+        logger.logger.debug('[WalletConnectProvider] disconnect - provider is not initialized');
+        return;
+    }
+    _a.connectionUri = undefined;
+    logger.logger.debug('[WalletConnectProvider] disconnecting from WalletConnect');
+    try {
+        yield _a.provider.disconnect();
+    }
+    catch (error) {
+        logger.logger.error('[WalletConnectProvider] Failed to disconnect from WalletConnect', error);
+    }
+});
+/**
+ * Waits for the provider to be initialized and returns the EthereumProvider instance.
+ * We should use this wherever possible (async methods), to ensure the provider is initialized.
+ */
+WalletConnectProvider.awaitAndGetProvider = () => _tslib.__awaiter(void 0, void 0, void 0, function* () { return _a.providerInitPromise; });
+/**
+ * Returns the EthereumProvider instance.
+ * Used when we need to access the provider synchronously.
+ */
+WalletConnectProvider.getProvider = () => _a.provider;
+WalletConnectProvider.getConnectionUri = () => _a.connectionUri;
+WalletConnectProvider.handleChainChangedEvent = (chain, onChainChanged) => {
+    logger.logger.debug('[WalletConnectProvider] handling chain change event', {
+        chain,
+    });
+    const chainId = utils.parseIntSafe(chain);
+    if (!chainId) {
+        return;
+    }
+    onChainChanged === null || onChainChanged === void 0 ? void 0 : onChainChanged(chainId);
+};
+WalletConnectProvider.handleAccountChangedEvent = (accounts, onAccountChanged) => {
+    logger.logger.debug('[WalletConnectProvider] handling account change event', {
+        accounts,
+    });
+    const [account] = accounts;
+    const address = account.includes(':') ? account.split(':').pop() : account;
+    if (!address) {
+        return;
+    }
+    onAccountChanged === null || onAccountChanged === void 0 ? void 0 : onAccountChanged(address);
+};
+/**
+ * Sets up event listeners for the provider.
+ */
+WalletConnectProvider.setupEventListeners = ({ onChainChanged, onAccountChanged, onDisconnect, }) => {
+    if (!_a.provider ||
+        _a.eventListenersSetup) {
+        return;
+    }
+    _a.chainChangedHandler = (chainId) => {
+        _a.handleChainChangedEvent(chainId, onChainChanged);
+    };
+    _a.accountChangedHandler = (account) => {
+        _a.handleAccountChangedEvent(account, onAccountChanged);
+    };
+    _a.disconnectHandler = () => {
+        logger.logger.debug('[WalletConnectProvider] handling disconnect event');
+        onDisconnect === null || onDisconnect === void 0 ? void 0 : onDisconnect();
+    };
+    _a.provider.on('accountsChanged', _a.accountChangedHandler);
+    _a.provider.on('chainChanged', _a.chainChangedHandler);
+    _a.provider.on('disconnect', _a.disconnectHandler);
+    _a.eventListenersSetup = true;
+};
+/**
+ * Tears down event listeners for the provider.
+ */
+WalletConnectProvider.teardownEventListeners = () => {
+    if (!_a.provider ||
+        !_a.eventListenersSetup) {
+        return;
+    }
+    _a.provider.off('accountsChanged', _a.accountChangedHandler);
+    _a.provider.off('chainChanged', _a.chainChangedHandler);
+    _a.provider.off('disconnect', _a.disconnectHandler);
+    _a.eventListenersSetup = false;
+};
+
+exports.WalletConnectProvider = WalletConnectProvider;

package/src/walletConnect/WalletConnectProvider/WalletConnectProvider.d.ts

@@ -6,16 +6,18 @@ type ProviderInitOpts = {
     storePrefix?: string;
 };
 export declare class WalletConnectProvider {
+    static isInitializing: boolean;
     static isInitialized: boolean;
     static projectId: string;
     static enabledNetworks: GenericNetwork[];
     static preferredChains: `eip155:${number}`[];
     static evmNetworkRpcMap: Record<string, string>;
+    private static providerInitPromise;
     private static provider;
     /**
      * The connection URI for the current connection.
      */
-    static connectionUri: string | undefined;
+    private static connectionUri;
     private static eventListenersSetup;
     private static accountChangedHandler;
     private static chainChangedHandler;
@@ -40,10 +42,17 @@ export declare class WalletConnectProvider {
      * It will kill the connection, but not the provider.
      */
     static disconnect: () => Promise<void>;
+    /**
+     * Waits for the provider to be initialized and returns the EthereumProvider instance.
+     * We should use this wherever possible (async methods), to ensure the provider is initialized.
+     */
+    static awaitAndGetProvider: () => Promise<EthereumProvider | undefined>;
     /**
      * Returns the EthereumProvider instance.
+     * Used when we need to access the provider synchronously.
      */
     static getProvider: () => EthereumProvider | undefined;
+    static getConnectionUri: () => string | undefined;
     private static handleChainChangedEvent;
     private static handleAccountChangedEvent;
     /**