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

package/CHANGELOG.md

@@ -1,4 +1,11 @@
 
+## [4.0.0-alpha.31](https://github.com/dynamic-labs/dynamic-auth/compare/v4.0.0-alpha.30...v4.0.0-alpha.31) (2024-11-13)
+
+
+### Features
+
+* allow passing telegram auth token into telegramSignIn function ([#7423](https://github.com/dynamic-labs/dynamic-auth/issues/7423)) ([4b8d594](https://github.com/dynamic-labs/dynamic-auth/commit/4b8d594984d1ac7851ce8d94fe4329ba94730f35))
+
 ## [4.0.0-alpha.30](https://github.com/dynamic-labs/dynamic-auth/compare/v4.0.0-alpha.29...v4.0.0-alpha.30) (2024-11-13)
 
 

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.0.0-alpha.30";
+var version = "4.0.0-alpha.31";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.0.0-alpha.30";
+var version = "4.0.0-alpha.31";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/ethereum",
-  "version": "4.0.0-alpha.30",
+  "version": "4.0.0-alpha.31",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -23,13 +23,15 @@
     "@walletconnect/types": "2.10.6",
     "eventemitter3": "5.0.1",
     "buffer": "6.0.3",
-    "@dynamic-labs/assert-package-version": "4.0.0-alpha.30",
-    "@dynamic-labs/embedded-wallet-evm": "4.0.0-alpha.30",
-    "@dynamic-labs/ethereum-core": "4.0.0-alpha.30",
-    "@dynamic-labs/types": "4.0.0-alpha.30",
-    "@dynamic-labs/utils": "4.0.0-alpha.30",
-    "@dynamic-labs/wallet-book": "4.0.0-alpha.30",
-    "@dynamic-labs/wallet-connector-core": "4.0.0-alpha.30"
+    "@metamask/sdk": "0.30.1",
+    "@dynamic-labs/assert-package-version": "4.0.0-alpha.31",
+    "@dynamic-labs/embedded-wallet-evm": "4.0.0-alpha.31",
+    "@dynamic-labs/ethereum-core": "4.0.0-alpha.31",
+    "@dynamic-labs/logger": "4.0.0-alpha.31",
+    "@dynamic-labs/types": "4.0.0-alpha.31",
+    "@dynamic-labs/utils": "4.0.0-alpha.31",
+    "@dynamic-labs/wallet-book": "4.0.0-alpha.31",
+    "@dynamic-labs/wallet-connector-core": "4.0.0-alpha.31"
   },
   "peerDependencies": {
     "viem": "^2.7.6"

package/src/ethProviderHelper.cjs

@@ -25,6 +25,9 @@ class EthProviderHelper {
         if (eip6963Provider) {
             return eip6963Provider;
         }
+        return this.getInjectedProvider();
+    }
+    getInjectedProvider() {
         const config = this.getInjectedConfig();
         if (!config ||
             !config.extensionLocators ||

package/src/ethProviderHelper.d.ts

@@ -9,6 +9,7 @@ export declare class EthProviderHelper {
     constructor(wallet: WalletSchema, connector?: InjectedWalletBase);
     private get connector();
     getInstalledProvider(): IEthereum | undefined;
+    getInjectedProvider(): IEthereum | undefined;
     getEip6963Provider(): IEthereum | undefined;
     getInjectedConfig(): {
         chain: string;

package/src/ethProviderHelper.js

@@ -21,6 +21,9 @@ class EthProviderHelper {
         if (eip6963Provider) {
             return eip6963Provider;
         }
+        return this.getInjectedProvider();
+    }
+    getInjectedProvider() {
         const config = this.getInjectedConfig();
         if (!config ||
             !config.extensionLocators ||

package/src/index.cjs

@@ -17,6 +17,7 @@ require('./walletConnect/walletConnect.cjs');
 var fetchWalletConnectWallets = require('./walletConnect/fetchWalletConnectWallets.cjs');
 var coinbase = require('./coinbase/coinbase.cjs');
 var ethereumCore = require('@dynamic-labs/ethereum-core');
+var MetaMaskConnector = require('./metaMask/MetaMaskConnector.cjs');
 var ethProviderHelper = require('./ethProviderHelper.cjs');
 var constants = require('./constants.cjs');
 
@@ -26,6 +27,7 @@ const EthereumWalletConnectors = (props) => [
     ...fetchInjectedWalletConnectors.fetchInjectedWalletConnector(props),
     ...fetchWalletConnectWallets.fetchWalletConnectWallets(props),
     ...embeddedWalletEvm.TurnkeyEVMWalletConnectors(props),
+    MetaMaskConnector.MetaMaskConnector,
     coinbase.Coinbase,
     UnknownInjected.UnknownInjected,
     FallbackEvmConnector.FallbackEvmConnector,

package/src/index.js

@@ -16,6 +16,7 @@ import './walletConnect/walletConnect.js';
 import { fetchWalletConnectWallets, getWalletConnectConnector } from './walletConnect/fetchWalletConnectWallets.js';
 import { Coinbase } from './coinbase/coinbase.js';
 export { EthereumWalletConnector, isEthereumWallet } from '@dynamic-labs/ethereum-core';
+import { MetaMaskConnector } from './metaMask/MetaMaskConnector.js';
 export { EthProviderHelper } from './ethProviderHelper.js';
 export { INFURA_ID } from './constants.js';
 
@@ -25,6 +26,7 @@ const EthereumWalletConnectors = (props) => [
     ...fetchInjectedWalletConnector(props),
     ...fetchWalletConnectWallets(props),
     ...TurnkeyEVMWalletConnectors(props),
+    MetaMaskConnector,
     Coinbase,
     UnknownInjected,
     FallbackEvmConnector,

package/src/injected/fetchInjectedWalletConnectors.cjs

@@ -18,6 +18,7 @@ const filteredInjectedWalletKeysOverrides = [
     'coinbase',
     'exodusevm',
     'abstract',
+    'metamask',
 ];
 const fetchInjectedWalletConnector = ({ walletBook, }) => {
     var _a;

package/src/injected/fetchInjectedWalletConnectors.js

@@ -14,6 +14,7 @@ const filteredInjectedWalletKeysOverrides = [
     'coinbase',
     'exodusevm',
     'abstract',
+    'metamask',
 ];
 const fetchInjectedWalletConnector = ({ walletBook, }) => {
     var _a;

package/src/metaMask/MetaMaskConnector.cjs

@@ -0,0 +1,399 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var sdk = require('@metamask/sdk');
+var viem = require('viem');
+var ethereumCore = require('@dynamic-labs/ethereum-core');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var utils = require('@dynamic-labs/utils');
+var walletBook = require('@dynamic-labs/wallet-book');
+var logger = require('../utils/logger.cjs');
+var ethProviderHelper = require('../ethProviderHelper.cjs');
+var createMetaMaskSDKDisplayUriState = require('./utils/createMetaMaskSDKDisplayUriState.cjs');
+var waitForConnection = require('./utils/waitForConnection.cjs');
+var isPendingWalletRequestPermissionError = require('./utils/isPendingWalletRequestPermissionError.cjs');
+
+/**
+ * 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 = utils.createEventTimeline();
+class MetaMaskConnector extends ethereumCore.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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.evmNetworks.map((network) => network.chainId.toString());
+        });
+    }
+    get ethProviderHelper() {
+        return new ethProviderHelper.EthProviderHelper(walletBook.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: utils.PlatformService.getOrigin(),
+        };
+        _metaMaskSDK = new sdk.MetaMaskSDK({
+            _source: 'dynamic-labs',
+            checkInstallationImmediately: true,
+            dappMetadata,
+            enableAnalytics: true,
+            extensionOnly: this.isInstalledOnBrowser(),
+            headless: true,
+            openDeeplink: utils.PlatformService.openURL,
+            preferDesktop: !utils.isMobile(),
+            readonlyRPCMap: getReadonlyRPCMap(this.evmNetworkRpcMap()),
+            useDeeplink: true,
+        });
+        _metaMaskSDKDisplayUriState =
+            createMetaMaskSDKDisplayUriState.createMetaMaskSDKDisplayUriState(_metaMaskSDK);
+    }
+    endSession() {
+        return _tslib.__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 (utils.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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                var _a, _b, _c, _d;
+                // QR Code flow
+                if (!utils.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) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    if (initialConnectedAccounts.length) {
+                        resolve(initialConnectedAccounts[0]);
+                        return;
+                    }
+                    try {
+                        yield this.metaMaskSDK.connect();
+                    }
+                    catch (error) {
+                        const isRequestPendingError = isPendingWalletRequestPermissionError.isPendingWalletRequestPermissionError(error);
+                        if (!isRequestPendingError) {
+                            throw error;
+                        }
+                        else {
+                            yield waitForConnection.waitForConnection(this.getProvider());
+                        }
+                    }
+                    const accounts = yield this.getConnectedAccounts();
+                    resolve(accounts[0]);
+                }));
+            });
+        });
+    }
+    getConnectedAccountsSafely() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const connectedAccounts = yield this.getConnectedAccounts();
+                return connectedAccounts;
+            }
+            catch (err) {
+                logger.logger.error(err);
+                return [];
+            }
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__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 utils.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 _tslib.__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 && utils.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 _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.metaMaskSDK.sdkInitPromise;
+            const metaMaskProvider = this.getProvider();
+            if (!metaMaskProvider) {
+                return;
+            }
+            const { handleAccountChange, handleChainChange, handleDisconnect } = walletConnectorCore.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 _tslib.__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 viem.createWalletClient({
+            account: address,
+            chain: network ? ethereumCore.getOrMapViemChain(network) : this.getActiveChain(),
+            transport: viem.custom(provider),
+        });
+    }
+    toInt(chainId) {
+        if (!chainId)
+            return undefined;
+        try {
+            return parseInt(chainId);
+        }
+        catch (err) {
+            logger.logger.debug(err);
+            return undefined;
+        }
+    }
+    getCurrentChainId() {
+        const provider = this.getProvider();
+        if (!provider) {
+            return undefined;
+        }
+        const chainId = provider.getChainId();
+        if (viem.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 (!utils.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 (!utils.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 walletBook.findWalletBookWallet(this.walletBook, this.key);
+    }
+}
+// Utils
+const getReadonlyRPCMap = (evmNetworkRpcMap) => Object.keys(evmNetworkRpcMap).reduce((acc, chainId) => (Object.assign(Object.assign({}, acc), { [viem.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)));
+
+exports.MetaMaskConnector = MetaMaskConnector;

package/src/metaMask/MetaMaskConnector.d.ts

@@ -0,0 +1,58 @@
+import { MetaMaskSDK } from '@metamask/sdk';
+import { Account, Transport, WalletClient, Chain as ViemChain } from 'viem';
+import { EthereumWalletConnector, EthereumWalletConnectorOpts } from '@dynamic-labs/ethereum-core';
+import { GetAddressOpts, IWalletConnectConnector } from '@dynamic-labs/wallet-connector-core';
+import { EthProviderHelper } from '../ethProviderHelper';
+import { MetaMaskSDKDisplayUriState } from './utils/createMetaMaskSDKDisplayUriState';
+export type MetaMaskConnectorProps = EthereumWalletConnectorOpts & {
+    appName: string;
+    appLogoUrl: string;
+};
+export declare const clearMetaMaskSdk: () => void;
+export declare class MetaMaskConnector extends EthereumWalletConnector implements IWalletConnectConnector {
+    name: string;
+    overrideKey: string;
+    canConnectViaQrCode: boolean;
+    private appName;
+    private appLogoUrl;
+    private isInAppBrowser;
+    constructor(props: MetaMaskConnectorProps);
+    getSupportedNetworks(): Promise<string[]>;
+    get ethProviderHelper(): EthProviderHelper | undefined;
+    get metaMaskSDK(): MetaMaskSDK;
+    set metaMaskSDK(metaMaskSDK: MetaMaskSDK);
+    get metaMaskSDKDisplayUriState(): MetaMaskSDKDisplayUriState;
+    createMetaMaskSDK(): void;
+    endSession(): Promise<void>;
+    getAddress(opts?: GetAddressOpts): Promise<string | undefined>;
+    private getConnectedAccountsSafely;
+    getConnectedAccounts(): Promise<string[]>;
+    signMessage(messageToSign: string, withAddress?: string): Promise<string | undefined>;
+    chooseAccountsToConnect(): Promise<never[]>;
+    getWalletClient(chainId?: string): WalletClient<Transport, ViemChain, Account> | undefined;
+    get rdns(): string;
+    isInstalledOnBrowser(): boolean;
+    setupEventListeners(): Promise<void>;
+    /**
+     * 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(): Promise<number | undefined>;
+    private getProvider;
+    private evmNetworkByChainId;
+    private getWalletClientForAddress;
+    private toInt;
+    private getCurrentChainId;
+    /**
+     * 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
+     */
+    private getIsInAppBrowser;
+    private shouldDeepLinkToMetaMaskInAppBrowser;
+    /**
+     * Get wallet book wallet information
+     */
+    private get wallet();
+}

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/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 };