@dynamic-labs/ethereum 2.0.0-alpha.8 → 2.0.0

package/src/walletConnect/walletConnect.js

@@ -1,10 +1,11 @@
 import { __awaiter } from '../../_virtual/_tslib.js';
-import Provider from '@walletconnect/universal-provider';
+import EthereumProvider from '@walletconnect/ethereum-provider';
 import EventEmitter from 'eventemitter3';
 import { createWalletClient, custom } from 'viem';
-import { DynamicError, sleep, isMobile } from '@dynamic-labs/utils';
-import { getWalletBookWallet } from '@dynamic-labs/wallet-book';
 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 { chainsMap } from '@dynamic-labs/viem-utils';
 import { EthWalletConnector } from '../EthWalletConnector.js';
 import { parseIntSafe } from '../utils/parseIntSafe.js';
 
@@ -26,6 +27,8 @@ class WalletConnect extends EthWalletConnector {
         // When trying to switch network for MetaMask, the switch promise gets stuck
         // if the switch got trigged once already, so we need to keep track of that
         this._hasSwitchedNetwork = false;
+        this.sessionEventHandler = () => { };
+        this.sessionDeleteHandler = () => { };
         this.name = opts.walletName;
         this.projectId = opts.projectId;
         this.deepLinkPreference = opts.deepLinkPreference || 'native';
@@ -47,7 +50,7 @@ class WalletConnect extends EthWalletConnector {
         const allChains = this.getMappedChains();
         const reorderedChains = this.preferredChains.filter((chain) => allChains.includes(chain));
         const remainingChains = allChains.filter((chain) => !this.preferredChains.includes(chain));
-        return [...reorderedChains, ...remainingChains];
+        return [...reorderedChains, ...remainingChains].map((chain) => Number(chain.split(':')[1]));
     }
     initConnection() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -56,43 +59,51 @@ class WalletConnect extends EthWalletConnector {
                 throw new DynamicError('No provider found (init connection)');
             }
             // this means there is already a connection in progress, so don't call connect again
-            if (provider === null || provider === void 0 ? void 0 : provider.uri) {
+            if (provider === null || provider === void 0 ? void 0 : provider.signer.uri) {
                 return;
             }
-            const optionalNamespaces = {
-                eip155: {
-                    chains: this.getMappedChainsByPreferredOrder(),
-                    events: ['chainChanged', 'accountsChanged'],
-                    methods: [
-                        'eth_chainId',
-                        'eth_signTypedData',
-                        'eth_signTransaction',
-                        'eth_sign',
-                        'personal_sign',
-                        'eth_sendTransaction',
-                        'eth_signTypedData_v4',
-                        'wallet_switchEthereumChain',
-                        'wallet_addEthereumChain',
-                    ],
-                    rpcMap: this.evmNetworkRpcMap(),
-                },
-            };
-            provider
-                .connect({
-                optionalNamespaces,
-            })
-                .catch((e) => {
+            provider.connect().catch((e) => {
                 logger.error(e);
                 ee.emit('walletconnect_connection_failed', e);
             });
         });
     }
-    createInitProviderPromise() {
+    createProvider() {
         return __awaiter(this, void 0, void 0, function* () {
-            WalletConnect.provider = yield Provider.init({
-                logger: logger.logLevel.toLowerCase() === 'debug' ? 'debug' : undefined,
+            return EthereumProvider.init({
+                events: ['chainChanged', 'accountsChanged'],
+                methods: [],
+                optionalChains: this.getMappedChainsByPreferredOrder(),
+                optionalMethods: [
+                    'eth_chainId',
+                    'eth_signTypedData',
+                    'eth_signTransaction',
+                    'eth_sign',
+                    'personal_sign',
+                    'eth_sendTransaction',
+                    'eth_signTypedData_v4',
+                    'wallet_switchEthereumChain',
+                    'wallet_addEthereumChain',
+                ],
                 projectId: this.projectId,
+                rpcMap: this.evmNetworkRpcMap(),
+                showQrModal: false,
+            });
+        });
+    }
+    getWalletClientFromInitializedProvider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletConnect = this.createProvider();
+            const walletClient = createWalletClient({
+                account: this.getActiveAccount(),
+                transport: custom(yield walletConnect),
             });
+            return walletClient;
+        });
+    }
+    createInitProviderPromise() {
+        return __awaiter(this, void 0, void 0, function* () {
+            WalletConnect.provider = yield this.createProvider();
             this.teardownEventListeners();
             this.setupEventListeners();
         });
@@ -117,7 +128,7 @@ class WalletConnect extends EthWalletConnector {
             if (localStorage.getItem(this.sessionTopicKey) ===
                 ((_d = (_c = WalletConnect.provider) === null || _c === void 0 ? void 0 : _c.session) === null || _d === void 0 ? void 0 : _d.topic)) {
                 this.session = WalletConnect.provider.session;
-                this.activeAccount = ((_e = localStorage.getItem(this.activeAccountKey)) !== null && _e !== void 0 ? _e : undefined);
+                this.setActiveAccount(((_e = localStorage.getItem(this.activeAccountKey)) !== null && _e !== void 0 ? _e : undefined));
             }
         }
     }
@@ -171,7 +182,7 @@ class WalletConnect extends EthWalletConnector {
         if (!WalletConnect.provider) {
             return;
         }
-        WalletConnect.provider.client.on('session_event', ({ params }) => {
+        this.sessionEventHandler = ({ params, }) => {
             logger.debug('session_event was called', { params });
             if (!params || !params.event) {
                 logger.debug('session_event was called without params or params.event');
@@ -180,12 +191,17 @@ class WalletConnect extends EthWalletConnector {
             const { name, data } = params.event;
             if (name === 'chainChanged') {
                 const chainId = parseIntSafe(data);
+                if (chainId === this.currentChainId) {
+                    logger.debug(`ignoring chainChanged event with same chain id as current chain id: ${chainId}`);
+                    return;
+                }
                 if (chainId === undefined) {
                     logger.debug(`received unexpected data for chainChanged: ${data} with type ${typeof data}}`);
                     return;
                 }
                 this.currentChainId = chainId;
                 this.emit('chainChange', { chain: String(chainId) });
+                this.hasSwitchedNetwork = true;
                 // When a user switches network from their wallet, we need the provider to change network
                 // such that any future calls to `getNetwork` will return the correct network
                 this.switchNetwork({ networkChainId: chainId });
@@ -197,36 +213,41 @@ class WalletConnect extends EthWalletConnector {
                 }
                 // eslint-disable-next-line prefer-destructuring
                 const account = data[0].split(':')[2];
-                this.setActiveAccount(account);
+                this.setWCActiveAccount(account);
             }
-        });
-        WalletConnect.provider.client.on('session_delete', () => __awaiter(this, void 0, void 0, function* () {
+        };
+        WalletConnect.provider.on('session_event', this.sessionEventHandler);
+        this.sessionDeleteHandler = () => __awaiter(this, void 0, void 0, function* () {
             this.endSession();
             this.emit('disconnect');
-        }));
+        });
+        WalletConnect.provider.on('session_delete', this.sessionDeleteHandler);
     }
     teardownEventListeners() {
         if (!WalletConnect.provider) {
             return;
         }
-        WalletConnect.provider.client.removeAllListeners('session_event');
-        WalletConnect.provider.client.removeAllListeners('session_delete');
+        WalletConnect.provider.off('session_event', this.sessionEventHandler);
+        WalletConnect.provider.off('session_delete', this.sessionDeleteHandler);
     }
-    getWalletClient() {
+    getWalletClient(chainId) {
         if (!WalletConnect.provider) {
             return;
         }
         return createWalletClient({
+            account: this.getActiveAccount(),
+            chain: chainsMap[chainId !== null && chainId !== void 0 ? chainId : String(this.currentChainId)],
             transport: custom(WalletConnect.provider),
         });
     }
-    fetchPublicAddress(opts) {
+    getAddress(opts) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.activeAccount) {
-                return this.activeAccount;
+            const activeAccount = this.getActiveAccount();
+            if (activeAccount === null || activeAccount === void 0 ? void 0 : activeAccount.address) {
+                return activeAccount.address;
             }
-            if (!WalletConnect.provider || !((_a = WalletConnect.provider) === null || _a === void 0 ? void 0 : _a.uri)) {
+            if (!WalletConnect.provider || !((_a = WalletConnect.provider) === null || _a === void 0 ? void 0 : _a.signer.uri)) {
                 logger.debug('No WC2 provider found, re-initializing...');
                 yield this.endSession();
                 yield this.init();
@@ -236,13 +257,13 @@ class WalletConnect extends EthWalletConnector {
                 // finish setting up the connection URI and making it available
                 // on the provider
                 yield sleep(1000);
-                if (!WalletConnect.provider || !((_b = WalletConnect.provider) === null || _b === void 0 ? void 0 : _b.uri)) {
+                if (!WalletConnect.provider || !((_b = WalletConnect.provider) === null || _b === void 0 ? void 0 : _b.signer.uri)) {
                     logger.debug('No WC2 provider found, escaping and throwing error');
                     throw new DynamicError('No provider found');
                 }
             }
-            const metadata = getWalletBookWallet(this.walletBook, this.key);
-            performPlatformSpecificConnectionMethod(WalletConnect.provider.uri, metadata, {
+            const metadata = getWalletBookWallet(this.walletBook, this.key, this.walletFallback);
+            performPlatformSpecificConnectionMethod(WalletConnect.provider.signer.uri, metadata, {
                 onDesktopUri: opts === null || opts === void 0 ? void 0 : opts.onDesktopUri,
                 onDisplayUri: opts === null || opts === void 0 ? void 0 : opts.onDisplayUri,
             }, this.deepLinkPreference);
@@ -255,7 +276,7 @@ class WalletConnect extends EthWalletConnector {
                     const error = new DynamicError('Connection rejected. Please try again.');
                     error.code = 'connection_rejected';
                     if (WalletConnect.provider) {
-                        WalletConnect.provider.uri = undefined;
+                        WalletConnect.provider.signer.uri = undefined;
                         // this is needed for mobile to work when using universal links.
                         // if the user cancels the connection, we need to re-initialize the provider
                         // so that the async work is done ahead of time, before the user tries to connect again,
@@ -267,13 +288,20 @@ class WalletConnect extends EthWalletConnector {
                     // whenever the connection attempt either succeeds or fails
                     cleanupListeners();
                 };
-                const onConnect = ({ session }) => {
+                const onConnect = () => {
+                    var _a;
+                    const session = (_a = WalletConnect.provider) === null || _a === void 0 ? void 0 : _a.session;
                     if (!session) {
                         reject(new DynamicError('No session found'));
+                        return;
                     }
                     this.setSession(session);
-                    this.setActiveAccount(session.namespaces.eip155.accounts[0].split(':')[2]);
-                    resolve(this.activeAccount);
+                    this.setWCActiveAccount(session.namespaces.eip155.accounts[0].split(':')[2]);
+                    this.getNetwork().then((chainId) => {
+                        var _a;
+                        this.currentChainId = chainId;
+                        resolve((_a = this.getActiveAccount()) === null || _a === void 0 ? void 0 : _a.address);
+                    });
                     // We must clean up the onConnect and onFail listeners
                     // whenever the connection attempt either succeeds or fails
                     cleanupListeners();
@@ -301,10 +329,12 @@ class WalletConnect extends EthWalletConnector {
      */
     waitForSignMessage(signMessageFn, messageToSign) {
         return __awaiter(this, void 0, void 0, function* () {
-            const raceConditionPromise = new Promise((resolve) => {
+            const raceConditionPromise = new Promise((resolve, reject) => {
                 // Create listener for chain change event
                 this.on('chainChange', () => resolve({ success: false }));
-                signMessageFn(messageToSign).then((result) => resolve({ signedMessage: result, success: true }));
+                signMessageFn(messageToSign)
+                    .then((result) => resolve({ signedMessage: result, success: true }))
+                    .catch(reject);
             });
             const signedMessageResult = yield raceConditionPromise;
             if (signedMessageResult.success === false) {
@@ -323,7 +353,7 @@ class WalletConnect extends EthWalletConnector {
             metadata,
             mode: 'regular',
             preference: this.deepLinkPreference,
-            uri: (_a = WalletConnect.provider) === null || _a === void 0 ? void 0 : _a.uri,
+            uri: (_a = WalletConnect.provider) === null || _a === void 0 ? void 0 : _a.signer.uri,
         });
         if (!deepLink) {
             return;
@@ -337,20 +367,17 @@ class WalletConnect extends EthWalletConnector {
             if (!this.session) {
                 throw new DynamicError('no session');
             }
-            const web3Provider = this.getWalletClient();
-            if (!web3Provider) {
-                throw new DynamicError('No WalletConnect provider found to handle signing');
-            }
             const deepLink = this.getDeepLink();
             if (isMobile() && deepLink) {
                 window.location.href = deepLink;
             }
             const signMessageFn = (messageToSign) => __awaiter(this, void 0, void 0, function* () {
-                const { activeAccount } = this;
+                const activeAccount = this.getActiveAccount();
                 if (!activeAccount) {
                     return;
                 }
-                return web3Provider.signMessage({
+                const walletClient = yield this.getWalletClientFromInitializedProvider();
+                return walletClient.signMessage({
                     account: activeAccount,
                     message: messageToSign,
                 });
@@ -361,15 +388,15 @@ class WalletConnect extends EthWalletConnector {
     }
     clearActiveAccount() {
         localStorage.removeItem(this.activeAccountKey);
-        this.activeAccount = undefined;
+        this.setActiveAccount(undefined);
     }
     clearSession() {
         localStorage.removeItem(this.sessionTopicKey);
         this.session = undefined;
     }
-    setActiveAccount(account) {
+    setWCActiveAccount(account) {
         localStorage.setItem(this.activeAccountKey, account);
-        this.activeAccount = account;
+        this.setActiveAccount(account);
         this.emit('accountChange', { accounts: [account] });
     }
     setSession(session) {
@@ -409,11 +436,17 @@ class WalletConnect extends EthWalletConnector {
             return _super.getNetwork.call(this);
         });
     }
-    providerSwitchNetwork({ network, provider, }) {
+    providerSwitchNetwork({ network, }) {
         const _super = Object.create(null, {
             providerSwitchNetwork: { get: () => super.providerSwitchNetwork }
         });
         return __awaiter(this, void 0, void 0, function* () {
+            const supportedNetworks = yield this.getSupportedNetworks();
+            if (!(supportedNetworks === null || supportedNetworks === void 0 ? void 0 : supportedNetworks.includes(network.chainId.toString()))) {
+                const error = new DynamicError('Network switching is not available at this time. The user should manually switch network in their wallet');
+                error.code = 'network_switching_only_available_in_wallet';
+                throw error;
+            }
             const currentNetworkId = yield this.getNetwork();
             if (currentNetworkId && currentNetworkId === network.chainId) {
                 return;
@@ -424,10 +457,14 @@ class WalletConnect extends EthWalletConnector {
             if (!this.supportsNetworkSwitching()) {
                 throw new DynamicError('Network switching not supported');
             }
-            if (!provider) {
-                throw new DynamicError('Provider not found');
+            const walletClient = yield this.getWalletClientFromInitializedProvider();
+            if (this.isMetaMask()) {
+                const deepLink = this.getDeepLink();
+                if (deepLink) {
+                    window.location.href = deepLink;
+                }
             }
-            yield _super.providerSwitchNetwork.call(this, { network, provider });
+            yield _super.providerSwitchNetwork.call(this, { network, provider: walletClient });
             this.currentChainId = network.chainId;
             this.hasSwitchedNetwork = true;
             this.emit('chainChange', { chain: String(network.chainId) });
@@ -440,10 +477,11 @@ class WalletConnect extends EthWalletConnector {
                 this.refreshSession();
                 this.isInitialized = true;
             }
-            if (!this.activeAccount) {
+            const activeAccount = this.getActiveAccount();
+            if (!(activeAccount === null || activeAccount === void 0 ? void 0 : activeAccount.address)) {
                 return [];
             }
-            return [this.activeAccount];
+            return [activeAccount.address];
         });
     }
     isMetaMask() {
@@ -453,13 +491,14 @@ class WalletConnect extends EthWalletConnector {
     getSupportedNetworks() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            // MM allows you to switch to any network the first time, even if it's not enabled in MM
-            // so we should consider all networks as supported if network switching hasn't been triggered yet
-            if (this.isMetaMask() && !this.hasSwitchedNetwork) {
-                return this.evmNetworks.map((network) => network.chainId.toString());
-            }
             yield this.initProvider();
             this.refreshSession();
+            if (this.isMetaMask()) {
+                if (this.hasSwitchedNetwork) {
+                    return [String(this.currentChainId)];
+                }
+                return this.evmNetworks.map((network) => network.chainId.toString());
+            }
             if (!this.session) {
                 return [];
             }