@metamask/connect-evm 0.4.0 → 0.5.0

package/dist/browser/es/connect-evm.mjs

@@ -46,22 +46,40 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// src/index.ts
-import { getInfuraRpcUrls } from "@metamask/connect-multichain";
+// src/utils/infura.ts
+import { getInfuraRpcUrls as getInfuraRpcUrlsMultichain } from "@metamask/connect-multichain";
+import {
+  KnownCaipNamespace,
+  numberToHex,
+  parseCaipChainId
+} from "@metamask/utils";
+var getInfuraRpcUrls = (infuraAPIKey) => {
+  const caipMap = getInfuraRpcUrlsMultichain(infuraAPIKey);
+  const hexMap = Object.entries(caipMap).reduce(
+    (acc, [key, url]) => {
+      const { namespace: namespace2, reference } = parseCaipChainId(key);
+      if (namespace2 !== KnownCaipNamespace.Eip155) {
+        return acc;
+      }
+      const chainId = numberToHex(parseInt(reference, 10));
+      acc[chainId] = url;
+      return acc;
+    },
+    {}
+  );
+  return hexMap;
+};
 
 // src/connect.ts
 import { analytics } from "@metamask/analytics";
+import { parseScopeString } from "@metamask/chain-agnostic-permission";
 import {
   createMultichainClient,
   getWalletActionAnalyticsProperties,
   isRejectionError,
   TransportType
 } from "@metamask/connect-multichain";
-import {
-  numberToHex as numberToHex2,
-  hexToNumber as hexToNumber2,
-  isHexString as isHex
-} from "@metamask/utils";
+import { hexToNumber as hexToNumber2 } from "@metamask/utils";
 
 // src/constants.ts
 var IGNORED_METHODS = [
@@ -96,15 +114,13 @@ import {
 } from "@metamask/connect-multichain";
 var namespace = "metamask-connect:evm";
 var logger = createLogger(namespace, "63");
-var enableDebug = (debugEnabled = false) => {
-  if (debugEnabled) {
-    debug(namespace);
-  }
+var enableDebug = () => {
+  debug(namespace);
 };
 
 // src/provider.ts
 import { EventEmitter } from "@metamask/connect-multichain";
-import { hexToNumber, numberToHex } from "@metamask/utils";
+import { hexToNumber } from "@metamask/utils";
 var _core, _requestInterceptor, _accounts, _selectedChainId;
 var EIP1193Provider = class extends EventEmitter {
   constructor(core, interceptor) {
@@ -148,8 +164,8 @@ var EIP1193Provider = class extends EventEmitter {
       if (!__privateGet(this, _selectedChainId)) {
         throw new Error("No chain ID selected");
       }
-      const chainId = hexToNumber(__privateGet(this, _selectedChainId));
-      const scope = `eip155:${chainId}`;
+      const decimalChainId = hexToNumber(__privateGet(this, _selectedChainId));
+      const scope = `eip155:${decimalChainId}`;
       const coreOptions = __privateGet(this, _core).options;
       const supportedNetworks = (_c = (_b = coreOptions == null ? void 0 : coreOptions.api) == null ? void 0 : _b.supportedNetworks) != null ? _c : {};
       if (!supportedNetworks[scope]) {
@@ -180,11 +196,7 @@ var EIP1193Provider = class extends EventEmitter {
     return __privateGet(this, _selectedChainId);
   }
   set selectedChainId(chainId) {
-    const hexChainId = chainId && typeof chainId === "number" ? numberToHex(chainId) : chainId;
-    if (!hexChainId) {
-      return;
-    }
-    __privateSet(this, _selectedChainId, hexChainId);
+    __privateSet(this, _selectedChainId, chainId);
   }
   // ==========================================
   // Legacy compatibility methods
@@ -198,6 +210,7 @@ var EIP1193Provider = class extends EventEmitter {
   }
   /**
    * Legacy method for sending JSON-RPC requests.
+   *
    * @deprecated Use `request` instead. This method is provided for backwards compatibility.
    * @param request - The JSON-RPC request object
    * @param callback - Optional callback function. If provided, the method returns void.
@@ -247,6 +260,7 @@ var EIP1193Provider = class extends EventEmitter {
   }
   /**
    * Legacy method for sending JSON-RPC requests synchronously (callback-based).
+   *
    * @deprecated Use `request` instead. This method is provided for backwards compatibility.
    * @param request - The JSON-RPC request object
    * @param callback - The callback function to receive the response
@@ -265,6 +279,15 @@ import {
   getPermittedEthChainIds as _getPermittedEthChainIds,
   getEthAccounts as _getEthAccounts
 } from "@metamask/chain-agnostic-permission";
+var getEthAccounts = (sessionScopes) => {
+  if (!sessionScopes) {
+    return [];
+  }
+  return _getEthAccounts({
+    requiredScopes: sessionScopes,
+    optionalScopes: sessionScopes
+  });
+};
 var getPermittedEthChainIds = (sessionScopes) => {
   if (!sessionScopes) {
     return [];
@@ -309,12 +332,13 @@ ${invalidUrls.join("\n")}`
 }
 
 // src/connect.ts
-var DEFAULT_CHAIN_ID = 1;
+var DEFAULT_CHAIN_ID = "0x1";
 var CHAIN_STORE_KEY = "cache_eth_chainId";
-var _core2, _provider, _sessionScopes, _eventHandlers, _sessionChangedHandler, _displayUriHandler, _removeNotificationHandler, _MetamaskConnectEVM_instances, getCoreOptions_fn, createInvokeOptions_fn, trackWalletActionRequested_fn, trackWalletActionSucceeded_fn, trackWalletActionFailed_fn, getSelectedChainId_fn, requestInterceptor_fn, clearConnectionState_fn, addEthereumChain_fn, request_fn, cacheChainId_fn, onChainChanged_fn, onAccountsChanged_fn, onConnect_fn, onDisconnect_fn, onDisplayUri_fn, attemptSessionRecovery_fn;
-var MetamaskConnectEVM = class {
+var _core2, _provider, _sessionScopes, _eventHandlers, _sessionChangedHandler, _displayUriHandler, _removeNotificationHandler, _status, _MetamaskConnectEVM_instances, getCoreOptions_fn, createInvokeOptions_fn, trackWalletActionRequested_fn, trackWalletActionSucceeded_fn, trackWalletActionFailed_fn, getSelectedChainId_fn, requestInterceptor_fn, clearConnectionState_fn, addEthereumChain_fn, request_fn, cacheChainId_fn, onSessionChanged_fn, onChainChanged_fn, onAccountsChanged_fn, onConnect_fn, onDisconnect_fn, onDisplayUri_fn;
+var _MetamaskConnectEVM = class _MetamaskConnectEVM {
   /**
    * Creates a new MetamaskConnectEVM instance.
+   * Use the static `create()` method instead to ensure proper async initialization.
    *
    * @param options - The options for the MetamaskConnectEVM instance
    * @param options.core - The core instance of the Multichain SDK
@@ -336,90 +360,88 @@ var MetamaskConnectEVM = class {
     __privateAdd(this, _displayUriHandler);
     /** The clean-up function for the notification handler */
     __privateAdd(this, _removeNotificationHandler);
+    /** The current connection status */
+    __privateAdd(this, _status, "disconnected");
     __privateSet(this, _core2, core);
     __privateSet(this, _provider, new EIP1193Provider(
       core,
       __privateMethod(this, _MetamaskConnectEVM_instances, requestInterceptor_fn).bind(this)
     ));
     __privateSet(this, _eventHandlers, eventHandlers);
-    __privateSet(this, _sessionChangedHandler, (session) => {
-      var _a;
-      logger("event: wallet_sessionChanged", session);
-      __privateSet(this, _sessionScopes, (_a = session == null ? void 0 : session.sessionScopes) != null ? _a : {});
-    });
-    __privateGet(this, _core2).on(
-      "wallet_sessionChanged",
-      __privateGet(this, _sessionChangedHandler).bind(this)
-    );
+    __privateSet(this, _sessionChangedHandler, __privateMethod(this, _MetamaskConnectEVM_instances, onSessionChanged_fn).bind(this));
+    __privateGet(this, _core2).on("wallet_sessionChanged", __privateGet(this, _sessionChangedHandler));
     __privateSet(this, _displayUriHandler, __privateMethod(this, _MetamaskConnectEVM_instances, onDisplayUri_fn).bind(this));
     __privateGet(this, _core2).on("display_uri", __privateGet(this, _displayUriHandler));
-    __privateMethod(this, _MetamaskConnectEVM_instances, attemptSessionRecovery_fn).call(this).catch((error) => {
-      console.error("Error attempting session recovery", error);
-    });
     logger("Connect/EVM constructor completed");
   }
+  /**
+   * Creates a fully initialized MetamaskConnectEVM instance.
+   * This is the recommended way to instantiate the class, as it ensures
+   * all async initialization (like session recovery) completes before
+   * the instance is returned.
+   *
+   * @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
+   * @returns A promise that resolves with a fully initialized MetamaskConnectEVM instance
+   */
+  static create(options) {
+    return __async(this, null, function* () {
+      const instance = new _MetamaskConnectEVM(options);
+      yield __privateGet(instance, _core2).emitSessionChanged();
+      return instance;
+    });
+  }
   /**
    * 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
+   * @param [options.account] - Optional param to specify an account to connect to
+   * @param [options.forceRequest] - Optional param to force a connection request regardless of whether there is a pre-existing session
+   * @param [options.chainIds] - Array of chain IDs to connect to (defaults to ethereum mainnet if not provided)
    * @returns A promise that resolves with the connected accounts and chain ID
    */
   connect() {
-    return __async(this, arguments, function* ({ account, forceRequest, chainIds } = {
-      chainIds: [DEFAULT_CHAIN_ID]
-    }) {
-      var _a, _b;
+    return __async(this, arguments, function* ({
+      account,
+      forceRequest,
+      chainIds = [DEFAULT_CHAIN_ID]
+    } = {}) {
+      var _a;
       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 : [DEFAULT_CHAIN_ID])
-      ).map((id) => `eip155:${id}`);
+      ).map((id) => `eip155:${hexToNumber2(id)}`);
       const caipAccountIds = account ? caipChainIds.map((caipChainId) => `${caipChainId}:${account}`) : [];
-      yield __privateGet(this, _core2).connect(
-        caipChainIds,
-        caipAccountIds,
-        void 0,
-        forceRequest
-      );
-      const hexPermittedChainIds = getPermittedEthChainIds(__privateGet(this, _sessionScopes));
-      const initialAccounts = yield __privateGet(this, _core2).transport.sendEip1193Message({ method: "eth_accounts", params: [] });
-      const chainId = yield __privateMethod(this, _MetamaskConnectEVM_instances, getSelectedChainId_fn).call(this, hexPermittedChainIds);
-      __privateMethod(this, _MetamaskConnectEVM_instances, onConnect_fn).call(this, {
-        chainId,
-        accounts: initialAccounts.result
-      });
-      (_b = __privateGet(this, _removeNotificationHandler)) == null ? void 0 : _b.call(this);
-      __privateSet(this, _removeNotificationHandler, __privateGet(this, _core2).transport.onNotification(
-        (notification) => {
-          var _a2;
-          if ((notification == null ? void 0 : notification.method) === "metamask_accountsChanged") {
-            const accounts = notification == null ? void 0 : notification.params;
-            logger("transport-event: accountsChanged", accounts);
-            __privateMethod(this, _MetamaskConnectEVM_instances, onAccountsChanged_fn).call(this, accounts);
-          }
-          if ((notification == null ? void 0 : notification.method) === "metamask_chainChanged") {
-            const notificationChainId = Number((_a2 = notification == null ? void 0 : notification.params) == null ? void 0 : _a2.chainId);
-            logger("transport-event: chainChanged", notificationChainId);
-            __privateMethod(this, _MetamaskConnectEVM_instances, cacheChainId_fn).call(this, notificationChainId).catch((error) => {
-              logger("Error caching chainId in notification handler", error);
+      __privateSet(this, _status, "connecting");
+      try {
+        const result = new Promise((resolve) => {
+          __privateGet(this, _provider).once("connect", ({ chainId, accounts }) => {
+            logger("fulfilled-request: connect", {
+              chainId,
+              accounts
             });
-            __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, notificationChainId);
-          }
-        }
-      ));
-      logger("fulfilled-request: connect", {
-        chainId: chainIds[0],
-        accounts: __privateGet(this, _provider).accounts
-      });
-      return {
-        accounts: __privateGet(this, _provider).accounts,
-        chainId: hexToNumber2(chainId)
-      };
+            resolve({
+              accounts,
+              chainId
+            });
+          });
+        });
+        yield __privateGet(this, _core2).connect(
+          caipChainIds,
+          caipAccountIds,
+          void 0,
+          forceRequest
+        );
+        return result;
+      } catch (error) {
+        __privateSet(this, _status, "disconnected");
+        logger("Error connecting to wallet", error);
+        throw error;
+      }
     });
   }
   /**
@@ -427,7 +449,7 @@ var MetamaskConnectEVM = class {
    *
    * @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)
+   * @param [options.chainIds] - Optional hex 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
    */
@@ -458,9 +480,9 @@ var MetamaskConnectEVM = class {
    * @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
+   * @param [options.chainIds] - Optional hex 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)
    */
@@ -498,16 +520,18 @@ var MetamaskConnectEVM = class {
    */
   disconnect() {
     return __async(this, null, function* () {
+      var _a;
       logger("request: disconnect");
-      yield __privateGet(this, _core2).disconnect();
+      const sessionScopes = __privateGet(this, _sessionScopes);
+      const eip155Scopes = Object.keys(sessionScopes).filter((scope) => {
+        const { namespace: namespace2 } = parseScopeString(scope);
+        return namespace2 === "eip155";
+      });
+      yield __privateGet(this, _core2).disconnect(eip155Scopes);
       __privateMethod(this, _MetamaskConnectEVM_instances, onDisconnect_fn).call(this);
       __privateMethod(this, _MetamaskConnectEVM_instances, clearConnectionState_fn).call(this);
-      __privateGet(this, _core2).off("wallet_sessionChanged", __privateGet(this, _sessionChangedHandler));
-      __privateGet(this, _core2).off("display_uri", __privateGet(this, _displayUriHandler));
-      if (__privateGet(this, _removeNotificationHandler)) {
-        __privateGet(this, _removeNotificationHandler).call(this);
-        __privateSet(this, _removeNotificationHandler, void 0);
-      }
+      (_a = __privateGet(this, _removeNotificationHandler)) == null ? void 0 : _a.call(this);
+      __privateSet(this, _removeNotificationHandler, void 0);
       logger("fulfilled-request: disconnect");
     });
   }
@@ -516,8 +540,8 @@ var MetamaskConnectEVM = class {
    *
    * @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
+   * @param [options.chainConfiguration] - The chain configuration to use in case the chain is not present by the wallet
+   * @returns A promise that resolves when the chain has been switched
    */
   switchChain(_0) {
     return __async(this, arguments, function* ({
@@ -525,17 +549,16 @@ var MetamaskConnectEVM = class {
       chainConfiguration
     }) {
       const method = "wallet_switchEthereumChain";
-      const hexChainId = isHex(chainId) ? chainId : numberToHex2(chainId);
-      const scope = `eip155:${isHex(chainId) ? hexToNumber2(chainId) : chainId}`;
-      const params = [{ chainId: hexChainId }];
+      const scope = `eip155:${hexToNumber2(chainId)}`;
+      const params = [{ chainId }];
       yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionRequested_fn).call(this, method, scope, params);
-      if (this.selectedChainId === hexChainId) {
+      if (this.selectedChainId === chainId) {
         return Promise.resolve();
       }
       const permittedChainIds = getPermittedEthChainIds(__privateGet(this, _sessionScopes));
-      if (permittedChainIds.includes(hexChainId) && __privateGet(this, _core2).transportType === TransportType.MWP) {
-        yield __privateMethod(this, _MetamaskConnectEVM_instances, cacheChainId_fn).call(this, hexChainId);
-        __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, hexChainId);
+      if (permittedChainIds.includes(chainId) && __privateGet(this, _core2).transportType === TransportType.MWP) {
+        yield __privateMethod(this, _MetamaskConnectEVM_instances, cacheChainId_fn).call(this, chainId);
+        __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, chainId);
         yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionSucceeded_fn).call(this, method, scope, params);
         return Promise.resolve();
       }
@@ -550,10 +573,10 @@ var MetamaskConnectEVM = class {
         }
         yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionSucceeded_fn).call(this, method, scope, params);
         if (result.result === null) {
-          yield __privateMethod(this, _MetamaskConnectEVM_instances, cacheChainId_fn).call(this, hexChainId);
-          __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, hexChainId);
+          yield __privateMethod(this, _MetamaskConnectEVM_instances, cacheChainId_fn).call(this, chainId);
+          __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, chainId);
         }
-        return result;
+        return Promise.resolve();
       } catch (error) {
         yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionFailed_fn).call(this, method, scope, params, error);
         if (error.message.includes("Unrecognized chain ID")) {
@@ -628,6 +651,7 @@ _eventHandlers = new WeakMap();
 _sessionChangedHandler = new WeakMap();
 _displayUriHandler = new WeakMap();
 _removeNotificationHandler = new WeakMap();
+_status = new WeakMap();
 _MetamaskConnectEVM_instances = new WeakSet();
 /**
  * Gets the core options for analytics checks.
@@ -722,6 +746,7 @@ getSelectedChainId_fn = function(permittedChainIds) {
 };
 requestInterceptor_fn = function(request) {
   return __async(this, null, function* () {
+    var _a;
     logger(`Intercepting request for method: ${request.method}`);
     if (IGNORED_METHODS.includes(request.method)) {
       return Promise.reject(
@@ -753,7 +778,7 @@ requestInterceptor_fn = function(request) {
     }
     if (isSwitchChainRequest(request)) {
       return this.switchChain({
-        chainId: parseInt(request.params[0].chainId, 16)
+        chainId: request.params[0].chainId
       });
     }
     if (isAddChainRequest(request)) {
@@ -761,8 +786,10 @@ requestInterceptor_fn = function(request) {
     }
     if (isAccountsRequest(request)) {
       const { method } = request;
-      const chainId = __privateGet(this, _provider).selectedChainId ? hexToNumber2(__privateGet(this, _provider).selectedChainId) : 1;
-      const scope = `eip155:${chainId}`;
+      const decimalChainId = hexToNumber2(
+        (_a = __privateGet(this, _provider).selectedChainId) != null ? _a : "0x1"
+      );
+      const scope = `eip155:${decimalChainId}`;
       const params = [];
       yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionRequested_fn).call(this, method, scope, params);
       yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionSucceeded_fn).call(this, method, scope, params);
@@ -784,14 +811,14 @@ clearConnectionState_fn = function() {
 };
 addEthereumChain_fn = function(chainConfiguration) {
   return __async(this, null, function* () {
-    var _a;
     logger("addEthereumChain called", { chainConfiguration });
     const method = "wallet_addEthereumChain";
     if (!chainConfiguration) {
       throw new Error("No chain configuration found.");
     }
-    const chainId = chainConfiguration.chainId ? parseInt(chainConfiguration.chainId, 16) : hexToNumber2((_a = __privateGet(this, _provider).selectedChainId) != null ? _a : "0x1");
-    const scope = `eip155:${chainId}`;
+    const chainId = chainConfiguration.chainId || __privateGet(this, _provider).selectedChainId || "0x1";
+    const decimalChainId = hexToNumber2(chainId);
+    const scope = `eip155:${decimalChainId}`;
     const params = [chainConfiguration];
     yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionRequested_fn).call(this, method, scope, params);
     try {
@@ -815,7 +842,7 @@ request_fn = function(request) {
     logger("direct request to metamask-provider called", request);
     const result = __privateGet(this, _core2).transport.sendEip1193Message(request);
     if (request.method === "wallet_addEthereumChain" || request.method === "wallet_switchEthereumChain") {
-      __privateGet(this, _core2).openDeeplinkIfNeeded();
+      __privateGet(this, _core2).openSimpleDeeplinkIfNeeded();
     }
     return result;
   });
@@ -823,31 +850,56 @@ request_fn = function(request) {
 cacheChainId_fn = function(chainId) {
   return __async(this, null, function* () {
     try {
-      const hexChainId = isHex(chainId) ? chainId : numberToHex2(chainId);
       yield __privateGet(this, _core2).storage.adapter.set(
         CHAIN_STORE_KEY,
-        JSON.stringify(hexChainId)
+        JSON.stringify(chainId)
       );
     } catch (error) {
       logger("Error caching chainId", error);
     }
   });
 };
+onSessionChanged_fn = function(session) {
+  return __async(this, null, function* () {
+    var _a;
+    logger("event: wallet_sessionChanged", session);
+    __privateSet(this, _sessionScopes, (_a = session == null ? void 0 : session.sessionScopes) != null ? _a : {});
+    const hexPermittedChainIds = getPermittedEthChainIds(__privateGet(this, _sessionScopes));
+    if (hexPermittedChainIds.length === 0) {
+      __privateMethod(this, _MetamaskConnectEVM_instances, onDisconnect_fn).call(this);
+    } else {
+      let initialAccounts = [];
+      if (__privateGet(this, _core2).status === "connected") {
+        const ethAccountsResponse = yield __privateGet(this, _core2).transport.sendEip1193Message({
+          method: "eth_accounts",
+          params: []
+        });
+        initialAccounts = ethAccountsResponse.result;
+      } else {
+        initialAccounts = getEthAccounts(__privateGet(this, _sessionScopes));
+      }
+      const chainId = yield __privateMethod(this, _MetamaskConnectEVM_instances, getSelectedChainId_fn).call(this, hexPermittedChainIds);
+      __privateMethod(this, _MetamaskConnectEVM_instances, onConnect_fn).call(this, {
+        chainId,
+        accounts: initialAccounts
+      });
+    }
+  });
+};
 /**
  * Handles chain change events and updates the provider's selected chain ID.
  *
- * @param chainId - The new chain ID (can be hex string or number)
+ * @param chainId - The new hex chain ID
  */
 onChainChanged_fn = function(chainId) {
   var _a, _b;
-  const hexChainId = isHex(chainId) ? chainId : numberToHex2(chainId);
-  if (hexChainId === __privateGet(this, _provider).selectedChainId) {
+  if (chainId === __privateGet(this, _provider).selectedChainId) {
     return;
   }
   logger("handler: chainChanged", { chainId });
   __privateGet(this, _provider).selectedChainId = chainId;
-  (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.chainChanged) == null ? void 0 : _b.call(_a, hexChainId);
-  __privateGet(this, _provider).emit("chainChanged", hexChainId);
+  (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.chainChanged) == null ? void 0 : _b.call(_a, chainId);
+  __privateGet(this, _provider).emit("chainChanged", chainId);
 };
 /**
  * Handles accounts change events and updates the provider's accounts list.
@@ -856,6 +908,10 @@ onChainChanged_fn = function(chainId) {
  */
 onAccountsChanged_fn = function(accounts) {
   var _a, _b;
+  const accountsUnchanged = accounts.length === __privateGet(this, _provider).accounts.length && accounts.every((acct, idx) => acct === __privateGet(this, _provider).accounts[idx]);
+  if (accountsUnchanged) {
+    return;
+  }
   logger("handler: accountsChanged", accounts);
   __privateGet(this, _provider).accounts = accounts;
   __privateGet(this, _provider).emit("accountsChanged", accounts);
@@ -865,21 +921,43 @@ onAccountsChanged_fn = function(accounts) {
  * Handles connection events and emits the connect event to listeners.
  *
  * @param options - The connection options
- * @param options.chainId - The chain ID of the connection (can be hex string or number)
+ * @param options.chainId - The hex chain ID of the connection
  * @param options.accounts - The accounts of the connection
  */
 onConnect_fn = function({
   chainId,
   accounts
 }) {
-  var _a, _b;
+  var _a, _b, _c;
   logger("handler: connect", { chainId, accounts });
   const data = {
-    chainId: isHex(chainId) ? chainId : numberToHex2(chainId),
+    chainId,
     accounts
   };
-  __privateGet(this, _provider).emit("connect", data);
-  (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.connect) == null ? void 0 : _b.call(_a, data);
+  if (__privateGet(this, _status) !== "connected") {
+    __privateSet(this, _status, "connected");
+    __privateGet(this, _provider).emit("connect", data);
+    (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.connect) == null ? void 0 : _b.call(_a, data);
+    (_c = __privateGet(this, _removeNotificationHandler)) == null ? void 0 : _c.call(this);
+    __privateSet(this, _removeNotificationHandler, __privateGet(this, _core2).transport.onNotification(
+      (notification) => {
+        var _a2;
+        if ((notification == null ? void 0 : notification.method) === "metamask_accountsChanged") {
+          const notificationAccounts = notification == null ? void 0 : notification.params;
+          logger("transport-event: accountsChanged", notificationAccounts);
+          __privateMethod(this, _MetamaskConnectEVM_instances, onAccountsChanged_fn).call(this, notificationAccounts);
+        }
+        if ((notification == null ? void 0 : notification.method) === "metamask_chainChanged") {
+          const notificationChainId = (_a2 = notification == null ? void 0 : notification.params) == null ? void 0 : _a2.chainId;
+          logger("transport-event: chainChanged", notificationChainId);
+          __privateMethod(this, _MetamaskConnectEVM_instances, cacheChainId_fn).call(this, notificationChainId).catch((error) => {
+            logger("Error caching chainId in notification handler", error);
+          });
+          __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, notificationChainId);
+        }
+      }
+    ));
+  }
   __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, chainId);
   __privateMethod(this, _MetamaskConnectEVM_instances, onAccountsChanged_fn).call(this, accounts);
 };
@@ -889,6 +967,10 @@ onConnect_fn = function({
  */
 onDisconnect_fn = function() {
   var _a, _b;
+  if (__privateGet(this, _status) === "disconnected") {
+    return;
+  }
+  __privateSet(this, _status, "disconnected");
   logger("handler: disconnect");
   __privateGet(this, _provider).emit("disconnect");
   (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.disconnect) == null ? void 0 : _b.call(_a);
@@ -902,39 +984,20 @@ onDisconnect_fn = function() {
  */
 onDisplayUri_fn = function(uri) {
   var _a, _b;
+  if (__privateGet(this, _status) !== "connecting") {
+    return;
+  }
   logger("handler: display_uri", uri);
   __privateGet(this, _provider).emit("display_uri", uri);
   (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.displayUri) == null ? void 0 : _b.call(_a, uri);
 };
-attemptSessionRecovery_fn = function() {
-  return __async(this, null, function* () {
-    if (__privateGet(this, _core2).status !== "connected" && __privateGet(this, _core2).status !== "connecting") {
-      return;
-    }
-    try {
-      const response = yield __privateGet(this, _core2).transport.request({
-        method: "wallet_getSession"
-      });
-      const { sessionScopes } = response.result;
-      __privateSet(this, _sessionScopes, sessionScopes);
-      const permittedChainIds = getPermittedEthChainIds(sessionScopes);
-      const permittedAccounts = yield __privateGet(this, _core2).transport.sendEip1193Message({ method: "eth_accounts", params: [] });
-      const chainId = yield __privateMethod(this, _MetamaskConnectEVM_instances, getSelectedChainId_fn).call(this, permittedChainIds);
-      if (permittedChainIds.length && permittedAccounts.result) {
-        __privateMethod(this, _MetamaskConnectEVM_instances, onConnect_fn).call(this, {
-          chainId,
-          accounts: permittedAccounts.result
-        });
-      }
-    } catch (error) {
-      console.error("Error attempting session recovery", error);
-    }
-  });
-};
+var MetamaskConnectEVM = _MetamaskConnectEVM;
 function createEVMClient(options) {
   return __async(this, null, function* () {
     var _a;
-    enableDebug(options.debug);
+    if (options.debug) {
+      enableDebug();
+    }
     logger("Creating Metamask Connect/EVM with options:", options);
     if (!((_a = options.api) == null ? void 0 : _a.supportedNetworks) || Object.keys(options.api.supportedNetworks).length === 0) {
       throw new Error(
@@ -942,13 +1005,21 @@ function createEVMClient(options) {
       );
     }
     validSupportedChainsUrls(options.api.supportedNetworks, "supportedNetworks");
+    const supportedNetworksCaipChainId = Object.entries(
+      options.api.supportedNetworks
+    ).reduce((acc, [hexChainId, url]) => {
+      const decimalChainId = parseInt(hexChainId, 16);
+      const caip2ChainId = `eip155:${decimalChainId}`;
+      acc[caip2ChainId] = url;
+      return acc;
+    }, {});
     try {
       const core = yield createMultichainClient(__spreadProps(__spreadValues({}, options), {
         api: {
-          supportedNetworks: options.api.supportedNetworks
+          supportedNetworks: supportedNetworksCaipChainId
         }
       }));
-      return new MetamaskConnectEVM({
+      return MetamaskConnectEVM.create({
         core,
         eventHandlers: options.eventHandlers,
         supportedNetworks: options.api.supportedNetworks