@metamask/connect-evm 0.1.1 → 0.2.0

package/dist/src/connect.js

@@ -0,0 +1,647 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _MetamaskConnectEVM_instances, _MetamaskConnectEVM_core, _MetamaskConnectEVM_provider, _MetamaskConnectEVM_sessionScopes, _MetamaskConnectEVM_eventHandlers, _MetamaskConnectEVM_sessionChangedHandler, _MetamaskConnectEVM_displayUriHandler, _MetamaskConnectEVM_removeNotificationHandler, _MetamaskConnectEVM_getCoreOptions, _MetamaskConnectEVM_createInvokeOptions, _MetamaskConnectEVM_trackWalletActionRequested, _MetamaskConnectEVM_trackWalletActionSucceeded, _MetamaskConnectEVM_trackWalletActionFailed, _MetamaskConnectEVM_getSelectedChainId, _MetamaskConnectEVM_requestInterceptor, _MetamaskConnectEVM_clearConnectionState, _MetamaskConnectEVM_addEthereumChain, _MetamaskConnectEVM_request, _MetamaskConnectEVM_cacheChainId, _MetamaskConnectEVM_onChainChanged, _MetamaskConnectEVM_onAccountsChanged, _MetamaskConnectEVM_onConnect, _MetamaskConnectEVM_onDisconnect, _MetamaskConnectEVM_onDisplayUri, _MetamaskConnectEVM_attemptSessionRecovery;
+import { analytics } from '@metamask/analytics';
+import { createMultichainClient, getWalletActionAnalyticsProperties, isRejectionError, TransportType, } from '@metamask/connect-multichain';
+import { numberToHex, hexToNumber, isHexString as isHex, } from '@metamask/utils';
+import { IGNORED_METHODS } from './constants';
+import { enableDebug, logger } from './logger';
+import { EIP1193Provider } from './provider';
+import { getPermittedEthChainIds } from './utils/caip';
+import { isAccountsRequest, isAddChainRequest, isConnectRequest, isSwitchChainRequest, validSupportedChainsUrls, } from './utils/type-guards';
+const DEFAULT_CHAIN_ID = 1;
+const CHAIN_STORE_KEY = 'cache_eth_chainId';
+/**
+ * The MetamaskConnectEVM class provides an EIP-1193 compatible interface for connecting
+ * to MetaMask and interacting with Ethereum Virtual Machine (EVM) networks.
+ *
+ * This class serves as a modern replacement for MetaMask SDK V1, offering enhanced
+ * functionality and cross-platform compatibility. It wraps the Multichain SDK to provide
+ * a simplified, EIP-1193 compliant API for dapp developers.
+ *
+ * Key features:
+ * - EIP-1193 provider interface for seamless integration with existing dapp code
+ * - Automatic session recovery when reloading or opening in new tabs
+ * - Chain switching with automatic chain addition if not configured
+ * - Event-driven architecture with support for connect, disconnect, accountsChanged, and chainChanged events
+ * - Cross-platform support for browser extensions and mobile applications
+ * - Built-in handling of common Ethereum methods (eth_accounts, wallet_switchEthereumChain, etc.)
+ *
+ * @example
+ * ```typescript
+ * const sdk = await createEVMClient({
+ *   dapp: { name: 'My DApp', url: 'https://mydapp.com' }
+ * });
+ *
+ * await sdk.connect({ chainId: 1 });
+ * const provider = await sdk.getProvider();
+ * const accounts = await provider.request({ method: 'eth_accounts' });
+ * ```
+ */
+export class MetamaskConnectEVM {
+    /**
+     * Creates a new MetamaskConnectEVM instance.
+     *
+     * @param options - The options for the MetamaskConnectEVM instance
+     * @param options.core - The core instance of the Multichain SDK
+     * @param options.eventHandlers - Optional event handlers for EIP-1193 provider events
+     */
+    constructor({ core, eventHandlers }) {
+        _MetamaskConnectEVM_instances.add(this);
+        /** The core instance of the Multichain SDK */
+        _MetamaskConnectEVM_core.set(this, void 0);
+        /** An instance of the EIP-1193 provider interface */
+        _MetamaskConnectEVM_provider.set(this, void 0);
+        /** The session scopes currently permitted */
+        _MetamaskConnectEVM_sessionScopes.set(this, {});
+        /** Optional event handlers for the EIP-1193 provider events. */
+        _MetamaskConnectEVM_eventHandlers.set(this, void 0);
+        /** The handler for the wallet_sessionChanged event */
+        _MetamaskConnectEVM_sessionChangedHandler.set(this, void 0);
+        /** The handler for the display_uri event */
+        _MetamaskConnectEVM_displayUriHandler.set(this, void 0);
+        /** The clean-up function for the notification handler */
+        _MetamaskConnectEVM_removeNotificationHandler.set(this, void 0);
+        __classPrivateFieldSet(this, _MetamaskConnectEVM_core, core, "f");
+        __classPrivateFieldSet(this, _MetamaskConnectEVM_provider, new EIP1193Provider(core, __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_requestInterceptor).bind(this)), "f");
+        __classPrivateFieldSet(this, _MetamaskConnectEVM_eventHandlers, eventHandlers, "f");
+        /**
+         * Handles the wallet_sessionChanged event.
+         * Updates the internal connection state with the new session data.
+         *
+         * @param session - The session data
+         */
+        __classPrivateFieldSet(this, _MetamaskConnectEVM_sessionChangedHandler, (session) => {
+            var _a;
+            logger('event: wallet_sessionChanged', session);
+            __classPrivateFieldSet(this, _MetamaskConnectEVM_sessionScopes, (_a = session === null || session === void 0 ? void 0 : session.sessionScopes) !== null && _a !== void 0 ? _a : {}, "f");
+        }, "f");
+        __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").on('wallet_sessionChanged', __classPrivateFieldGet(this, _MetamaskConnectEVM_sessionChangedHandler, "f").bind(this));
+        /**
+         * Handles the display_uri event.
+         * Forwards the QR code URI to the provider for custom UI implementations.
+         */
+        __classPrivateFieldSet(this, _MetamaskConnectEVM_displayUriHandler, __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onDisplayUri).bind(this), "f");
+        __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").on('display_uri', __classPrivateFieldGet(this, _MetamaskConnectEVM_displayUriHandler, "f"));
+        // Attempt to set the permitted accounts if there's a valid previous session.
+        // TODO (wenfix): does it make sense to catch here?
+        __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_attemptSessionRecovery).call(this).catch((error) => {
+            console.error('Error attempting session recovery', error);
+        });
+        logger('Connect/EVM constructor completed');
+    }
+    /**
+     * Connects to the wallet with the specified chain ID and optional account.
+     *
+     * @param options - The connection options
+     * @param options.account - Optional specific account to connect to
+     * @param options.forceRequest - Wwhether to force a request regardless of an existing session
+     * @param options.chainIds - Array of chain IDs to connect to
+     * @returns A promise that resolves with the connected accounts and chain ID
+     */
+    connect() {
+        return __awaiter(this, arguments, void 0, function* ({ account, forceRequest, chainIds } = {
+            chainIds: [DEFAULT_CHAIN_ID],
+        }) {
+            var _a, _b;
+            logger('request: connect', { account });
+            if (!chainIds || chainIds.length === 0) {
+                throw new Error('chainIds must be an array of at least one chain ID');
+            }
+            const caipChainIds = Array.from(new Set((_a = chainIds.concat(DEFAULT_CHAIN_ID)) !== null && _a !== void 0 ? _a : [DEFAULT_CHAIN_ID])).map((id) => `eip155:${id}`);
+            const caipAccountIds = account
+                ? caipChainIds.map((caipChainId) => `${caipChainId}:${account}`)
+                : [];
+            yield __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").connect(caipChainIds, caipAccountIds, {}, forceRequest);
+            const hexPermittedChainIds = getPermittedEthChainIds(__classPrivateFieldGet(this, _MetamaskConnectEVM_sessionScopes, "f"));
+            const initialAccounts = yield __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").transport.sendEip1193Message({ method: 'eth_accounts', params: [] });
+            const chainId = yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_getSelectedChainId).call(this, hexPermittedChainIds);
+            __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onConnect).call(this, {
+                chainId,
+                accounts: initialAccounts.result,
+            });
+            // Remove previous notification handler if it exists
+            (_b = __classPrivateFieldGet(this, _MetamaskConnectEVM_removeNotificationHandler, "f")) === null || _b === void 0 ? void 0 : _b.call(this);
+            __classPrivateFieldSet(this, _MetamaskConnectEVM_removeNotificationHandler, __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").transport.onNotification((notification) => {
+                var _a;
+                // @ts-expect-error TODO: address this
+                if ((notification === null || notification === void 0 ? void 0 : notification.method) === 'metamask_accountsChanged') {
+                    // @ts-expect-error TODO: address this
+                    const accounts = notification === null || notification === void 0 ? void 0 : notification.params;
+                    logger('transport-event: accountsChanged', accounts);
+                    __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onAccountsChanged).call(this, accounts);
+                }
+                // @ts-expect-error TODO: address this
+                if ((notification === null || notification === void 0 ? void 0 : notification.method) === 'metamask_chainChanged') {
+                    // @ts-expect-error TODO: address this
+                    const notificationChainId = Number((_a = notification === null || notification === void 0 ? void 0 : notification.params) === null || _a === void 0 ? void 0 : _a.chainId);
+                    logger('transport-event: chainChanged', notificationChainId);
+                    // Cache the chainId for persistence across page refreshes
+                    __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_cacheChainId).call(this, notificationChainId).catch((error) => {
+                        logger('Error caching chainId in notification handler', error);
+                    });
+                    __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onChainChanged).call(this, notificationChainId);
+                }
+            }), "f");
+            logger('fulfilled-request: connect', {
+                chainId: chainIds[0],
+                accounts: __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").accounts,
+            });
+            // TODO: update required here since accounts and chainId are now promises
+            return {
+                accounts: __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").accounts,
+                chainId: hexToNumber(chainId),
+            };
+        });
+    }
+    /**
+     * Connects to the wallet and signs a message using personal_sign.
+     *
+     * @param options - The connection options
+     * @param options.message - The message to sign after connecting
+     * @param options.chainIds - Optional chain IDs to connect to (defaults to ethereum mainnet if not provided)
+     * @returns A promise that resolves with the signature
+     * @throws Error if the selected account is not available after timeout
+     */
+    connectAndSign(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ message, chainIds, }) {
+            var _b, _c;
+            const { accounts, chainId } = yield this.connect({
+                chainIds: chainIds !== null && chainIds !== void 0 ? chainIds : [DEFAULT_CHAIN_ID],
+            });
+            const result = (yield __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").request({
+                method: 'personal_sign',
+                params: [accounts[0], message],
+            }));
+            (_c = (_b = __classPrivateFieldGet(this, _MetamaskConnectEVM_eventHandlers, "f")) === null || _b === void 0 ? void 0 : _b.connectAndSign) === null || _c === void 0 ? void 0 : _c.call(_b, {
+                accounts,
+                chainId,
+                signResponse: result,
+            });
+            return result;
+        });
+    }
+    /**
+     * Connects to the wallet and invokes a method with specified parameters.
+     *
+     * @param options - The options for connecting and invoking the method
+     * @param options.method - The method name to invoke
+     * @param options.params - The parameters to pass to the method, or a function that receives the account and returns params
+     * @param options.chainIds - Optional chain IDs to connect to (defaults to ethereum mainnet if not provided)
+     * @param options.account - Optional specific account to connect to
+     * @param options.forceRequest - Whether to force a request regardless of an existing session
+     * @returns A promise that resolves with the result of the method invocation
+     * @throws Error if the selected account is not available after timeout (for methods that require an account)
+     */
+    connectWith(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ method, params, chainIds, account, forceRequest, }) {
+            var _b, _c;
+            const { accounts: connectedAccounts, chainId: connectedChainId } = yield this.connect({
+                chainIds: chainIds !== null && chainIds !== void 0 ? chainIds : [DEFAULT_CHAIN_ID],
+                account,
+                forceRequest,
+            });
+            const resolvedParams = typeof params === 'function' ? params(connectedAccounts[0]) : params;
+            const result = yield __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").request({
+                method,
+                params: resolvedParams,
+            });
+            (_c = (_b = __classPrivateFieldGet(this, _MetamaskConnectEVM_eventHandlers, "f")) === null || _b === void 0 ? void 0 : _b.connectWith) === null || _c === void 0 ? void 0 : _c.call(_b, {
+                accounts: connectedAccounts,
+                chainId: connectedChainId,
+                connectWithResponse: result,
+            });
+            return result;
+        });
+    }
+    /**
+     * Disconnects from the wallet by revoking the session and cleaning up event listeners.
+     *
+     * @returns A promise that resolves when disconnection is complete
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger('request: disconnect');
+            yield __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").disconnect();
+            __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onDisconnect).call(this);
+            __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_clearConnectionState).call(this);
+            __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").off('wallet_sessionChanged', __classPrivateFieldGet(this, _MetamaskConnectEVM_sessionChangedHandler, "f"));
+            __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").off('display_uri', __classPrivateFieldGet(this, _MetamaskConnectEVM_displayUriHandler, "f"));
+            if (__classPrivateFieldGet(this, _MetamaskConnectEVM_removeNotificationHandler, "f")) {
+                __classPrivateFieldGet(this, _MetamaskConnectEVM_removeNotificationHandler, "f").call(this);
+                __classPrivateFieldSet(this, _MetamaskConnectEVM_removeNotificationHandler, undefined, "f");
+            }
+            logger('fulfilled-request: disconnect');
+        });
+    }
+    /**
+     * Switches the Ethereum chain. Will track state internally whenever possible.
+     *
+     * @param options - The options for the switch chain request
+     * @param options.chainId - The chain ID to switch to
+     * @param options.chainConfiguration - The chain configuration to use in case the chain is not present by the wallet
+     * @returns The result of the switch chain request
+     */
+    switchChain(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ chainId, chainConfiguration, }) {
+            const method = 'wallet_switchEthereumChain';
+            const hexChainId = isHex(chainId) ? chainId : numberToHex(chainId);
+            const scope = `eip155:${isHex(chainId) ? hexToNumber(chainId) : chainId}`;
+            const params = [{ chainId: hexChainId }];
+            yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionRequested).call(this, method, scope, params);
+            // TODO (wenfix): better way to return here other than resolving.
+            if (this.selectedChainId === hexChainId) {
+                return Promise.resolve();
+            }
+            const permittedChainIds = getPermittedEthChainIds(__classPrivateFieldGet(this, _MetamaskConnectEVM_sessionScopes, "f"));
+            if (permittedChainIds.includes(hexChainId) &&
+                __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").transportType === TransportType.MWP) {
+                yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_cacheChainId).call(this, hexChainId);
+                __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onChainChanged).call(this, hexChainId);
+                yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionSucceeded).call(this, method, scope, params);
+                return Promise.resolve();
+            }
+            try {
+                const result = yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_request).call(this, {
+                    method: 'wallet_switchEthereumChain',
+                    params,
+                });
+                // When using the MWP transport, the error is returned instead of thrown,
+                // so we force it into the catch block here.
+                const resultWithError = result;
+                if (resultWithError === null || resultWithError === void 0 ? void 0 : resultWithError.error) {
+                    throw new Error(resultWithError.error.message);
+                }
+                yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionSucceeded).call(this, method, scope, params);
+                if (result.result === null) {
+                    // result is successful we eagerly call onChainChanged to update the provider's selected chain ID.
+                    yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_cacheChainId).call(this, hexChainId);
+                    __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onChainChanged).call(this, hexChainId);
+                }
+                return result;
+            }
+            catch (error) {
+                yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionFailed).call(this, method, scope, params, error);
+                // Fallback to add the chain if its not configured in the wallet.
+                if (error.message.includes('Unrecognized chain ID')) {
+                    return __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_addEthereumChain).call(this, chainConfiguration);
+                }
+                throw error;
+            }
+        });
+    }
+    /**
+     * Gets the EIP-1193 provider instance
+     *
+     * @returns The EIP-1193 provider instance
+     */
+    getProvider() {
+        return __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f");
+    }
+    /**
+     * Gets the currently selected chain ID on the wallet
+     *
+     * @returns The currently selected chain ID or undefined if no chain is selected
+     */
+    getChainId() {
+        return this.selectedChainId;
+    }
+    /**
+     * Gets the currently selected account on the wallet
+     *
+     * @returns The currently selected account or undefined if no account is selected
+     */
+    getAccount() {
+        return __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").selectedAccount;
+    }
+    // Convenience getters for the EIP-1193 provider
+    /**
+     * Gets the currently permitted accounts
+     *
+     * @returns The currently permitted accounts
+     */
+    get accounts() {
+        return __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").accounts;
+    }
+    /**
+     * Gets the currently selected account on the wallet
+     *
+     * @returns The currently selected account or undefined if no account is selected
+     */
+    get selectedAccount() {
+        return __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").selectedAccount;
+    }
+    /**
+     * Gets the currently selected chain ID on the wallet
+     *
+     * @returns The currently selected chain ID or undefined if no chain is selected
+     */
+    get selectedChainId() {
+        return __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").selectedChainId;
+    }
+}
+_MetamaskConnectEVM_core = new WeakMap(), _MetamaskConnectEVM_provider = new WeakMap(), _MetamaskConnectEVM_sessionScopes = new WeakMap(), _MetamaskConnectEVM_eventHandlers = new WeakMap(), _MetamaskConnectEVM_sessionChangedHandler = new WeakMap(), _MetamaskConnectEVM_displayUriHandler = new WeakMap(), _MetamaskConnectEVM_removeNotificationHandler = new WeakMap(), _MetamaskConnectEVM_instances = new WeakSet(), _MetamaskConnectEVM_getCoreOptions = function _MetamaskConnectEVM_getCoreOptions() {
+    return __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").options;
+}, _MetamaskConnectEVM_createInvokeOptions = function _MetamaskConnectEVM_createInvokeOptions(method, scope, params) {
+    return {
+        scope,
+        request: { method, params },
+    };
+}, _MetamaskConnectEVM_trackWalletActionRequested = function _MetamaskConnectEVM_trackWalletActionRequested(method, scope, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const coreOptions = __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_getCoreOptions).call(this);
+        try {
+            const invokeOptions = __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_createInvokeOptions).call(this, method, scope, params);
+            const props = yield getWalletActionAnalyticsProperties(coreOptions, __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").storage, invokeOptions);
+            analytics.track('mmconnect_wallet_action_requested', props);
+        }
+        catch (error) {
+            logger('Error tracking mmconnect_wallet_action_requested event', error);
+        }
+    });
+}, _MetamaskConnectEVM_trackWalletActionSucceeded = function _MetamaskConnectEVM_trackWalletActionSucceeded(method, scope, params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const coreOptions = __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_getCoreOptions).call(this);
+        try {
+            const invokeOptions = __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_createInvokeOptions).call(this, method, scope, params);
+            const props = yield getWalletActionAnalyticsProperties(coreOptions, __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").storage, invokeOptions);
+            analytics.track('mmconnect_wallet_action_succeeded', props);
+        }
+        catch (error) {
+            logger('Error tracking mmconnect_wallet_action_succeeded event', error);
+        }
+    });
+}, _MetamaskConnectEVM_trackWalletActionFailed = function _MetamaskConnectEVM_trackWalletActionFailed(method, scope, params, error) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const coreOptions = __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_getCoreOptions).call(this);
+        try {
+            const invokeOptions = __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_createInvokeOptions).call(this, method, scope, params);
+            const props = yield getWalletActionAnalyticsProperties(coreOptions, __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").storage, invokeOptions);
+            const isRejection = isRejectionError(error);
+            if (isRejection) {
+                analytics.track('mmconnect_wallet_action_rejected', props);
+            }
+            else {
+                analytics.track('mmconnect_wallet_action_failed', props);
+            }
+        }
+        catch (_a) {
+            logger('Error tracking wallet action rejected or failed event', error);
+        }
+    });
+}, _MetamaskConnectEVM_getSelectedChainId = function _MetamaskConnectEVM_getSelectedChainId(permittedChainIds) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const cachedChainId = yield __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").storage.adapter.get(CHAIN_STORE_KEY);
+            if (cachedChainId) {
+                const chainId = JSON.parse(cachedChainId);
+                // Validate that the cached chainId is in the permitted chains list
+                if (permittedChainIds.includes(chainId)) {
+                    return chainId;
+                }
+            }
+        }
+        catch (error) {
+            logger('Error retrieving cached chainId', error);
+        }
+        // Fallback to the first permitted chain if cache retrieval failed or returned an invalid chain
+        return permittedChainIds[0];
+    });
+}, _MetamaskConnectEVM_requestInterceptor = function _MetamaskConnectEVM_requestInterceptor(request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger(`Intercepting request for method: ${request.method}`);
+        if (IGNORED_METHODS.includes(request.method)) {
+            // TODO: replace with correct method unsupported provider error
+            return Promise.reject(new Error(`Method: ${request.method} is not supported by Metamask Connect/EVM`));
+        }
+        if (request.method === 'wallet_revokePermissions') {
+            return this.disconnect();
+        }
+        if (isConnectRequest(request)) {
+            // When calling wallet_requestPermissions, we need to force a new session request to prompt
+            // the user for accounts, because internally the Multichain SDK will check if
+            // the user is already connected and skip the request if so, unless we
+            // explicitly request a specific account. This is needed to workaround
+            // wallet_requestPermissions not requesting specific accounts.
+            const shouldForceConnectionRequest = request.method === 'wallet_requestPermissions';
+            const { method, params } = request;
+            const initiallySelectedChainId = DEFAULT_CHAIN_ID;
+            const scope = `eip155:${initiallySelectedChainId}`;
+            yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionRequested).call(this, method, scope, params);
+            try {
+                const result = yield this.connect({
+                    chainIds: [initiallySelectedChainId],
+                    forceRequest: shouldForceConnectionRequest,
+                });
+                yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionSucceeded).call(this, method, scope, params);
+                return result;
+            }
+            catch (error) {
+                yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionFailed).call(this, method, scope, params, error);
+                throw error;
+            }
+        }
+        if (isSwitchChainRequest(request)) {
+            return this.switchChain({
+                chainId: parseInt(request.params[0].chainId, 16),
+            });
+        }
+        if (isAddChainRequest(request)) {
+            return __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_addEthereumChain).call(this, request.params[0]);
+        }
+        if (isAccountsRequest(request)) {
+            const { method } = request;
+            const chainId = __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").selectedChainId
+                ? hexToNumber(__classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").selectedChainId)
+                : 1;
+            const scope = `eip155:${chainId}`;
+            const params = [];
+            yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionRequested).call(this, method, scope, params);
+            yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionSucceeded).call(this, method, scope, params);
+            return __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").accounts;
+        }
+        logger('Request not intercepted, forwarding to default handler', request);
+        return Promise.resolve();
+    });
+}, _MetamaskConnectEVM_clearConnectionState = function _MetamaskConnectEVM_clearConnectionState() {
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").accounts = [];
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").selectedChainId = undefined;
+}, _MetamaskConnectEVM_addEthereumChain = function _MetamaskConnectEVM_addEthereumChain(chainConfiguration) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        logger('addEthereumChain called', { chainConfiguration });
+        const method = 'wallet_addEthereumChain';
+        if (!chainConfiguration) {
+            throw new Error('No chain configuration found.');
+        }
+        // Get chain ID from config or use current chain
+        const chainId = chainConfiguration.chainId
+            ? parseInt(chainConfiguration.chainId, 16)
+            : hexToNumber((_a = __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").selectedChainId) !== null && _a !== void 0 ? _a : '0x1');
+        const scope = `eip155:${chainId}`;
+        const params = [chainConfiguration];
+        yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionRequested).call(this, method, scope, params);
+        try {
+            const result = yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_request).call(this, {
+                method: 'wallet_addEthereumChain',
+                params,
+            });
+            if (result.result === null) {
+                // if result is successful we eagerly call onChainChanged to update the provider's selected chain ID.
+                yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_cacheChainId).call(this, chainId);
+                __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onChainChanged).call(this, chainId);
+            }
+            yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionSucceeded).call(this, method, scope, params);
+        }
+        catch (error) {
+            yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_trackWalletActionFailed).call(this, method, scope, params, error);
+            throw error;
+        }
+    });
+}, _MetamaskConnectEVM_request = function _MetamaskConnectEVM_request(request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger('direct request to metamask-provider called', request);
+        const result = __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").transport.sendEip1193Message(request);
+        if (request.method === 'wallet_addEthereumChain' ||
+            request.method === 'wallet_switchEthereumChain') {
+            __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").openDeeplinkIfNeeded();
+        }
+        return result;
+    });
+}, _MetamaskConnectEVM_cacheChainId = function _MetamaskConnectEVM_cacheChainId(chainId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const hexChainId = isHex(chainId) ? chainId : numberToHex(chainId);
+            yield __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").storage.adapter.set(CHAIN_STORE_KEY, JSON.stringify(hexChainId));
+        }
+        catch (error) {
+            logger('Error caching chainId', error);
+        }
+    });
+}, _MetamaskConnectEVM_onChainChanged = function _MetamaskConnectEVM_onChainChanged(chainId) {
+    var _a, _b;
+    const hexChainId = isHex(chainId) ? chainId : numberToHex(chainId);
+    if (hexChainId === __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").selectedChainId) {
+        return;
+    }
+    logger('handler: chainChanged', { chainId });
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").selectedChainId = chainId;
+    (_b = (_a = __classPrivateFieldGet(this, _MetamaskConnectEVM_eventHandlers, "f")) === null || _a === void 0 ? void 0 : _a.chainChanged) === null || _b === void 0 ? void 0 : _b.call(_a, hexChainId);
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").emit('chainChanged', hexChainId);
+}, _MetamaskConnectEVM_onAccountsChanged = function _MetamaskConnectEVM_onAccountsChanged(accounts) {
+    var _a, _b;
+    logger('handler: accountsChanged', accounts);
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").accounts = accounts;
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").emit('accountsChanged', accounts);
+    (_b = (_a = __classPrivateFieldGet(this, _MetamaskConnectEVM_eventHandlers, "f")) === null || _a === void 0 ? void 0 : _a.accountsChanged) === null || _b === void 0 ? void 0 : _b.call(_a, accounts);
+}, _MetamaskConnectEVM_onConnect = function _MetamaskConnectEVM_onConnect({ chainId, accounts, }) {
+    var _a, _b;
+    logger('handler: connect', { chainId, accounts });
+    const data = {
+        chainId: isHex(chainId) ? chainId : numberToHex(chainId),
+        accounts,
+    };
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").emit('connect', data);
+    (_b = (_a = __classPrivateFieldGet(this, _MetamaskConnectEVM_eventHandlers, "f")) === null || _a === void 0 ? void 0 : _a.connect) === null || _b === void 0 ? void 0 : _b.call(_a, data);
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onChainChanged).call(this, chainId);
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onAccountsChanged).call(this, accounts);
+}, _MetamaskConnectEVM_onDisconnect = function _MetamaskConnectEVM_onDisconnect() {
+    var _a, _b;
+    logger('handler: disconnect');
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").emit('disconnect');
+    (_b = (_a = __classPrivateFieldGet(this, _MetamaskConnectEVM_eventHandlers, "f")) === null || _a === void 0 ? void 0 : _a.disconnect) === null || _b === void 0 ? void 0 : _b.call(_a);
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onAccountsChanged).call(this, []);
+}, _MetamaskConnectEVM_onDisplayUri = function _MetamaskConnectEVM_onDisplayUri(uri) {
+    var _a, _b;
+    logger('handler: display_uri', uri);
+    __classPrivateFieldGet(this, _MetamaskConnectEVM_provider, "f").emit('display_uri', uri);
+    (_b = (_a = __classPrivateFieldGet(this, _MetamaskConnectEVM_eventHandlers, "f")) === null || _a === void 0 ? void 0 : _a.displayUri) === null || _b === void 0 ? void 0 : _b.call(_a, uri);
+}, _MetamaskConnectEVM_attemptSessionRecovery = function _MetamaskConnectEVM_attemptSessionRecovery() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Skip session recovery if transport is not initialized yet.
+        // Transport is only initialized when there's a stored session or after connect() is called.
+        // Only attempt recovery if we're in a state where transport should be available.
+        if (__classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").status !== 'connected' && __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").status !== 'connecting') {
+            return;
+        }
+        try {
+            const response = yield __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").transport.request({
+                method: 'wallet_getSession',
+            });
+            const { sessionScopes } = response.result;
+            __classPrivateFieldSet(this, _MetamaskConnectEVM_sessionScopes, sessionScopes, "f");
+            const permittedChainIds = getPermittedEthChainIds(sessionScopes);
+            // Instead of using the accounts we get back from calling `wallet_getSession`
+            // we get permitted accounts from `eth_accounts` to make sure we have them ordered by last selected account
+            // and correctly set the currently selected account for the dapp
+            const permittedAccounts = yield __classPrivateFieldGet(this, _MetamaskConnectEVM_core, "f").transport.sendEip1193Message({ method: 'eth_accounts', params: [] });
+            const chainId = yield __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_getSelectedChainId).call(this, permittedChainIds);
+            if (permittedChainIds.length && permittedAccounts.result) {
+                __classPrivateFieldGet(this, _MetamaskConnectEVM_instances, "m", _MetamaskConnectEVM_onConnect).call(this, {
+                    chainId,
+                    accounts: permittedAccounts.result,
+                });
+            }
+        }
+        catch (error) {
+            console.error('Error attempting session recovery', error);
+        }
+    });
+};
+/**
+ * Creates a new Metamask Connect/EVM instance
+ *
+ * @param options - The options for the Metamask Connect/EVM layer
+ * @param options.dapp - Dapp identification and branding settings
+ * @param options.api - API configuration including read-only RPC map
+ * @param options.api.supportedNetworks - A map of CAIP chain IDs to RPC URLs for read-only requests
+ * @param options.eventEmitter - The event emitter to use for the Metamask Connect/EVM layer
+ * @param options.eventHandlers - The event handlers to use for the Metamask Connect/EVM layer
+ * @returns The Metamask Connect/EVM layer instance
+ */
+export function createEVMClient(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        enableDebug(options.debug);
+        logger('Creating Metamask Connect/EVM with options:', options);
+        // Validate that supportedNetworks is provided and not empty
+        if (!((_a = options.api) === null || _a === void 0 ? void 0 : _a.supportedNetworks) ||
+            Object.keys(options.api.supportedNetworks).length === 0) {
+            throw new Error('supportedNetworks is required and must contain at least one chain configuration');
+        }
+        validSupportedChainsUrls(options.api.supportedNetworks, 'supportedNetworks');
+        try {
+            const core = yield createMultichainClient(Object.assign(Object.assign({}, options), { api: {
+                    supportedNetworks: options.api.supportedNetworks,
+                } }));
+            return new MetamaskConnectEVM({
+                core,
+                eventHandlers: options.eventHandlers,
+                supportedNetworks: options.api.supportedNetworks,
+            });
+        }
+        catch (error) {
+            console.error('Error creating Metamask Connect/EVM', error);
+            throw error;
+        }
+    });
+}
+//# sourceMappingURL=connect.js.map