@metamask/connect-evm 0.1.0

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

@@ -0,0 +1,794 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+import { getInfuraRpcUrls } from "@metamask/connect-multichain";
+
+// src/connect.ts
+import { analytics } from "@metamask/analytics";
+import {
+  createMetamaskConnect,
+  getWalletActionAnalyticsProperties,
+  isRejectionError,
+  TransportType
+} from "@metamask/connect-multichain";
+import {
+  numberToHex as numberToHex2,
+  hexToNumber as hexToNumber2,
+  isHexString as isHex
+} from "@metamask/utils";
+
+// src/constants.ts
+var IGNORED_METHODS = [
+  "metamask_getProviderState",
+  "metamask_sendDomainMetadata",
+  "metamask_logWeb3ShimUsage",
+  "wallet_registerOnboarding",
+  "net_version",
+  "wallet_getPermissions"
+];
+var CONNECT_METHODS = [
+  "wallet_requestPermissions",
+  "eth_requestAccounts"
+];
+var ACCOUNTS_METHODS = ["eth_accounts", "eth_coinbase"];
+var INTERCEPTABLE_METHODS = [
+  ...ACCOUNTS_METHODS,
+  ...IGNORED_METHODS,
+  ...CONNECT_METHODS,
+  // These have bespoke handlers
+  "wallet_revokePermissions",
+  "wallet_switchEthereumChain",
+  "wallet_addEthereumChain"
+];
+
+// src/logger.ts
+import {
+  createLogger,
+  enableDebug as debug
+} from "@metamask/connect-multichain";
+var namespace = "metamask-connect:evm";
+var logger = createLogger(namespace, "63");
+var enableDebug = (debugEnabled = false) => {
+  if (debugEnabled) {
+    debug(namespace);
+  }
+};
+
+// src/provider.ts
+import { EventEmitter } from "@metamask/connect-multichain";
+import { hexToNumber, numberToHex } from "@metamask/utils";
+var _core, _requestInterceptor, _accounts, _selectedChainId;
+var EIP1193Provider = class extends EventEmitter {
+  constructor(core, interceptor) {
+    super();
+    /** The core instance of the Multichain SDK */
+    __privateAdd(this, _core);
+    /** Interceptor function to handle specific methods */
+    __privateAdd(this, _requestInterceptor);
+    /** The currently permitted accounts */
+    __privateAdd(this, _accounts, []);
+    /** The currently selected chain ID on the wallet */
+    __privateAdd(this, _selectedChainId);
+    __privateSet(this, _core, core);
+    __privateSet(this, _requestInterceptor, interceptor);
+  }
+  /**
+   * Performs a EIP-1193 request.
+   *
+   * @param request - The request object containing the method and params
+   * @returns The result of the request
+   */
+  request(request) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      logger(
+        `request: ${request.method} - chainId: ${this.selectedChainId}`,
+        request.params
+      );
+      if (INTERCEPTABLE_METHODS.includes(request.method)) {
+        return (_a = __privateGet(this, _requestInterceptor)) == null ? void 0 : _a.call(this, request);
+      }
+      if (!__privateGet(this, _selectedChainId)) {
+        throw new Error("No chain ID selected");
+      }
+      const chainId = hexToNumber(__privateGet(this, _selectedChainId));
+      const scope = `eip155:${chainId}`;
+      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]) {
+        throw new Error(
+          `Chain ${scope} is not configured in supportedNetworks. Requests cannot be made to chains not explicitly configured in supportedNetworks.`
+        );
+      }
+      return __privateGet(this, _core).invokeMethod({
+        scope,
+        request: {
+          method: request.method,
+          params: request.params
+        }
+      });
+    });
+  }
+  // Getters and setters
+  get selectedAccount() {
+    return this.accounts[0];
+  }
+  set accounts(accounts) {
+    __privateSet(this, _accounts, accounts);
+  }
+  get accounts() {
+    return __privateGet(this, _accounts);
+  }
+  get selectedChainId() {
+    return __privateGet(this, _selectedChainId);
+  }
+  set selectedChainId(chainId) {
+    const hexChainId = chainId && typeof chainId === "number" ? numberToHex(chainId) : chainId;
+    if (!hexChainId) {
+      return;
+    }
+    __privateSet(this, _selectedChainId, hexChainId);
+  }
+};
+_core = new WeakMap();
+_requestInterceptor = new WeakMap();
+_accounts = new WeakMap();
+_selectedChainId = new WeakMap();
+
+// src/utils/caip.ts
+import {
+  getPermittedEthChainIds as _getPermittedEthChainIds,
+  getEthAccounts as _getEthAccounts
+} from "@metamask/chain-agnostic-permission";
+var getPermittedEthChainIds = (sessionScopes) => {
+  if (!sessionScopes) {
+    return [];
+  }
+  return _getPermittedEthChainIds({
+    requiredScopes: sessionScopes,
+    optionalScopes: sessionScopes
+  });
+};
+
+// src/utils/type-guards.ts
+function isConnectRequest(req) {
+  return req.method === "wallet_requestPermissions" || req.method === "eth_requestAccounts";
+}
+function isSwitchChainRequest(req) {
+  return req.method === "wallet_switchEthereumChain";
+}
+function isAddChainRequest(req) {
+  return req.method === "wallet_addEthereumChain";
+}
+function isAccountsRequest(req) {
+  return req.method === "eth_accounts" || req.method === "eth_coinbase";
+}
+function validSupportedChainsUrls(record, recordName) {
+  const invalidUrls = [];
+  for (const [key, url] of Object.entries(record)) {
+    try {
+      new URL(url);
+    } catch (e) {
+      invalidUrls.push(`${key}: ${url}`);
+    }
+  }
+  if (invalidUrls.length > 0) {
+    throw new Error(
+      `${recordName} contains invalid URLs:
+${invalidUrls.join("\n")}`
+    );
+  }
+}
+
+// src/connect.ts
+var DEFAULT_CHAIN_ID = 1;
+var _core2, _provider, _sessionScopes, _eventHandlers, _sessionChangedHandler, _MetamaskConnectEVM_instances, getCoreOptions_fn, createInvokeOptions_fn, trackWalletActionRequested_fn, trackWalletActionSucceeded_fn, trackWalletActionFailed_fn, requestInterceptor_fn, clearConnectionState_fn, addEthereumChain_fn, request_fn, onChainChanged_fn, onAccountsChanged_fn, onConnect_fn, onDisconnect_fn, attemptSessionRecovery_fn;
+var MetamaskConnectEVM = class {
+  /**
+   * 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 }) {
+    __privateAdd(this, _MetamaskConnectEVM_instances);
+    /** The core instance of the Multichain SDK */
+    __privateAdd(this, _core2);
+    /** An instance of the EIP-1193 provider interface */
+    __privateAdd(this, _provider);
+    /** The session scopes currently permitted */
+    __privateAdd(this, _sessionScopes, {});
+    /** Optional event handlers for the EIP-1193 provider events. */
+    __privateAdd(this, _eventHandlers);
+    /** The handler for the wallet_sessionChanged event */
+    __privateAdd(this, _sessionChangedHandler);
+    __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)
+    );
+    __privateMethod(this, _MetamaskConnectEVM_instances, attemptSessionRecovery_fn).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.chainId - The chain ID to connect to (defaults to 1 for mainnet)
+   * @param options.account - Optional specific account to connect to
+   * @param options.forceRequest - Wwhether to force a request regardless of an existing session
+   * @returns A promise that resolves with the connected accounts and chain ID
+   */
+  connect() {
+    return __async(this, arguments, function* ({
+      chainId,
+      account,
+      forceRequest
+    } = { chainId: DEFAULT_CHAIN_ID }) {
+      logger("request: connect", { chainId, account });
+      const caipChainId = chainId ? [`eip155:${chainId}`] : [];
+      const caipAccountId = chainId && account ? [`eip155:${chainId}:${account}`] : [];
+      yield __privateGet(this, _core2).connect(caipChainId, caipAccountId, forceRequest);
+      const hexPermittedChainIds = getPermittedEthChainIds(__privateGet(this, _sessionScopes));
+      const initialChainId = hexPermittedChainIds[0];
+      const initialAccounts = yield __privateGet(this, _core2).transport.sendEip1193Message({ method: "eth_accounts", params: [] });
+      __privateMethod(this, _MetamaskConnectEVM_instances, onConnect_fn).call(this, {
+        chainId: initialChainId,
+        accounts: initialAccounts.result
+      });
+      __privateGet(this, _core2).transport.onNotification((notification) => {
+        var _a;
+        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((_a = notification == null ? void 0 : notification.params) == null ? void 0 : _a.chainId);
+          logger("transport-event: chainChanged", notificationChainId);
+          __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, notificationChainId);
+        }
+      });
+      logger("fulfilled-request: connect", {
+        chainId,
+        accounts: __privateGet(this, _provider).accounts
+      });
+      return {
+        accounts: __privateGet(this, _provider).accounts,
+        chainId: hexToNumber2(initialChainId)
+      };
+    });
+  }
+  /**
+   * Connects to the wallet and signs a message using personal_sign.
+   *
+   * @param message - The message to sign
+   * @returns A promise that resolves with the signature
+   * @throws Error if the selected account is not available after timeout
+   */
+  connectAndSign(message) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const { accounts, chainId } = yield this.connect();
+      const result = yield __privateGet(this, _provider).request({
+        method: "personal_sign",
+        params: [accounts[0], message]
+      });
+      (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.connectAndSign) == null ? void 0 : _b.call(_a, {
+        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.chainId - Optional chain ID to connect to (defaults to mainnet)
+   * @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(_0) {
+    return __async(this, arguments, function* ({
+      method,
+      params,
+      chainId,
+      account,
+      forceRequest
+    }) {
+      var _a, _b;
+      const { accounts: connectedAccounts, chainId: connectedChainId } = yield this.connect({
+        chainId: chainId != null ? chainId : DEFAULT_CHAIN_ID,
+        account,
+        forceRequest
+      });
+      const resolvedParams = typeof params === "function" ? params(connectedAccounts[0]) : params;
+      const result = yield __privateGet(this, _provider).request({
+        method,
+        params: resolvedParams
+      });
+      (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.connectWith) == null ? void 0 : _b.call(_a, {
+        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 __async(this, null, function* () {
+      logger("request: disconnect");
+      yield __privateGet(this, _core2).disconnect();
+      __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));
+      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(_0) {
+    return __async(this, arguments, function* ({
+      chainId,
+      chainConfiguration
+    }) {
+      const method = "wallet_switchEthereumChain";
+      const hexChainId = isHex(chainId) ? chainId : numberToHex2(chainId);
+      const scope = `eip155:${isHex(chainId) ? hexToNumber2(chainId) : chainId}`;
+      const params = [{ chainId: hexChainId }];
+      yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionRequested_fn).call(this, method, scope, params);
+      if (this.selectedChainId === hexChainId) {
+        return Promise.resolve();
+      }
+      const permittedChainIds = getPermittedEthChainIds(__privateGet(this, _sessionScopes));
+      if (permittedChainIds.includes(hexChainId) && __privateGet(this, _core2).transportType === TransportType.MWP) {
+        __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, hexChainId);
+        yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionSucceeded_fn).call(this, method, scope, params);
+        return Promise.resolve();
+      }
+      try {
+        const result = yield __privateMethod(this, _MetamaskConnectEVM_instances, request_fn).call(this, {
+          method: "wallet_switchEthereumChain",
+          params
+        });
+        yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionSucceeded_fn).call(this, method, scope, params);
+        return result;
+      } catch (error) {
+        yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionFailed_fn).call(this, method, scope, params, error);
+        if (error.message.includes("Unrecognized chain ID")) {
+          return __privateMethod(this, _MetamaskConnectEVM_instances, addEthereumChain_fn).call(this, chainConfiguration);
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Gets the EIP-1193 provider instance
+   *
+   * @returns The EIP-1193 provider instance
+   */
+  getProvider() {
+    return __privateGet(this, _provider);
+  }
+  /**
+   * 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 __privateGet(this, _provider).selectedAccount;
+  }
+  // Convenience getters for the EIP-1193 provider
+  /**
+   * Gets the currently permitted accounts
+   *
+   * @returns The currently permitted accounts
+   */
+  get accounts() {
+    return __privateGet(this, _provider).accounts;
+  }
+  /**
+   * Gets the currently selected account on the wallet
+   *
+   * @returns The currently selected account or undefined if no account is selected
+   */
+  get selectedAccount() {
+    return __privateGet(this, _provider).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 __privateGet(this, _provider).selectedChainId;
+  }
+};
+_core2 = new WeakMap();
+_provider = new WeakMap();
+_sessionScopes = new WeakMap();
+_eventHandlers = new WeakMap();
+_sessionChangedHandler = new WeakMap();
+_MetamaskConnectEVM_instances = new WeakSet();
+/**
+ * Gets the core options for analytics checks.
+ *
+ * @returns The multichain options from the core instance
+ */
+getCoreOptions_fn = function() {
+  return __privateGet(this, _core2).options;
+};
+/**
+ * Creates invoke options for analytics tracking.
+ *
+ * @param method - The RPC method name
+ * @param scope - The CAIP chain ID scope
+ * @param params - The method parameters
+ * @returns Invoke options object for analytics
+ */
+createInvokeOptions_fn = function(method, scope, params) {
+  return {
+    scope,
+    request: { method, params }
+  };
+};
+trackWalletActionRequested_fn = function(method, scope, params) {
+  return __async(this, null, function* () {
+    var _a;
+    const coreOptions = __privateMethod(this, _MetamaskConnectEVM_instances, getCoreOptions_fn).call(this);
+    if (!((_a = coreOptions.analytics) == null ? void 0 : _a.enabled)) {
+      return;
+    }
+    try {
+      const invokeOptions = __privateMethod(this, _MetamaskConnectEVM_instances, createInvokeOptions_fn).call(this, method, scope, params);
+      const props = yield getWalletActionAnalyticsProperties(
+        coreOptions,
+        __privateGet(this, _core2).storage,
+        invokeOptions
+      );
+      analytics.track("mmconnect_wallet_action_requested", props);
+    } catch (error) {
+      logger("Error tracking mmconnect_wallet_action_requested event", error);
+    }
+  });
+};
+trackWalletActionSucceeded_fn = function(method, scope, params) {
+  return __async(this, null, function* () {
+    var _a;
+    const coreOptions = __privateMethod(this, _MetamaskConnectEVM_instances, getCoreOptions_fn).call(this);
+    if (!((_a = coreOptions.analytics) == null ? void 0 : _a.enabled)) {
+      return;
+    }
+    try {
+      const invokeOptions = __privateMethod(this, _MetamaskConnectEVM_instances, createInvokeOptions_fn).call(this, method, scope, params);
+      const props = yield getWalletActionAnalyticsProperties(
+        coreOptions,
+        __privateGet(this, _core2).storage,
+        invokeOptions
+      );
+      analytics.track("mmconnect_wallet_action_succeeded", props);
+    } catch (error) {
+      logger("Error tracking mmconnect_wallet_action_succeeded event", error);
+    }
+  });
+};
+trackWalletActionFailed_fn = function(method, scope, params, error) {
+  return __async(this, null, function* () {
+    var _a;
+    const coreOptions = __privateMethod(this, _MetamaskConnectEVM_instances, getCoreOptions_fn).call(this);
+    if (!((_a = coreOptions.analytics) == null ? void 0 : _a.enabled)) {
+      return;
+    }
+    try {
+      const invokeOptions = __privateMethod(this, _MetamaskConnectEVM_instances, createInvokeOptions_fn).call(this, method, scope, params);
+      const props = yield getWalletActionAnalyticsProperties(
+        coreOptions,
+        __privateGet(this, _core2).storage,
+        invokeOptions
+      );
+      const isRejection = isRejectionError(error);
+      if (isRejection) {
+        analytics.track("mmconnect_wallet_action_rejected", props);
+      } else {
+        analytics.track("mmconnect_wallet_action_failed", props);
+      }
+    } catch (e) {
+      logger("Error tracking wallet action rejected or failed event", error);
+    }
+  });
+};
+requestInterceptor_fn = function(request) {
+  return __async(this, null, function* () {
+    logger(`Intercepting request for method: ${request.method}`);
+    if (IGNORED_METHODS.includes(request.method)) {
+      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)) {
+      const shouldForceConnectionRequest = request.method === "wallet_requestPermissions";
+      const { method, params } = request;
+      const chainId = DEFAULT_CHAIN_ID;
+      const scope = `eip155:${chainId}`;
+      yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionRequested_fn).call(this, method, scope, params);
+      try {
+        const result = yield this.connect({
+          chainId,
+          forceRequest: shouldForceConnectionRequest
+        });
+        yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionSucceeded_fn).call(this, method, scope, params);
+        return result;
+      } catch (error) {
+        yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionFailed_fn).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 __privateMethod(this, _MetamaskConnectEVM_instances, addEthereumChain_fn).call(this, request.params[0]);
+    }
+    if (isAccountsRequest(request)) {
+      const { method } = request;
+      const chainId = __privateGet(this, _provider).selectedChainId ? hexToNumber2(__privateGet(this, _provider).selectedChainId) : 1;
+      const scope = `eip155:${chainId}`;
+      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);
+      return __privateGet(this, _provider).accounts;
+    }
+    logger("Request not intercepted, forwarding to default handler", request);
+    return Promise.resolve();
+  });
+};
+/**
+ * Clears the internal connection state: accounts and chainId
+ */
+clearConnectionState_fn = function() {
+  __privateGet(this, _provider).accounts = [];
+  __privateGet(this, _provider).selectedChainId = void 0;
+};
+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 params = [chainConfiguration];
+    yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionRequested_fn).call(this, method, scope, params);
+    try {
+      yield __privateMethod(this, _MetamaskConnectEVM_instances, request_fn).call(this, {
+        method: "wallet_addEthereumChain",
+        params
+      });
+      yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionSucceeded_fn).call(this, method, scope, params);
+    } catch (error) {
+      yield __privateMethod(this, _MetamaskConnectEVM_instances, trackWalletActionFailed_fn).call(this, method, scope, params, error);
+      throw error;
+    }
+  });
+};
+request_fn = function(request) {
+  return __async(this, null, function* () {
+    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();
+    }
+    return result;
+  });
+};
+/**
+ * Handles chain change events and updates the provider's selected chain ID.
+ *
+ * @param chainId - The new chain ID (can be hex string or number)
+ */
+onChainChanged_fn = function(chainId) {
+  var _a, _b;
+  const hexChainId = isHex(chainId) ? chainId : numberToHex2(chainId);
+  if (hexChainId === __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);
+};
+/**
+ * Handles accounts change events and updates the provider's accounts list.
+ *
+ * @param accounts - The new list of permitted accounts
+ */
+onAccountsChanged_fn = function(accounts) {
+  var _a, _b;
+  logger("handler: accountsChanged", accounts);
+  __privateGet(this, _provider).accounts = accounts;
+  __privateGet(this, _provider).emit("accountsChanged", accounts);
+  (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.accountsChanged) == null ? void 0 : _b.call(_a, 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.accounts - The accounts of the connection
+ */
+onConnect_fn = function({
+  chainId,
+  accounts
+}) {
+  var _a, _b;
+  logger("handler: connect", { chainId, accounts });
+  const data = {
+    chainId: isHex(chainId) ? chainId : numberToHex2(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);
+  __privateMethod(this, _MetamaskConnectEVM_instances, onChainChanged_fn).call(this, chainId);
+  __privateMethod(this, _MetamaskConnectEVM_instances, onAccountsChanged_fn).call(this, accounts);
+};
+/**
+ * Handles disconnection events and emits the disconnect event to listeners.
+ * Also clears accounts by triggering an accountsChanged event with an empty array.
+ */
+onDisconnect_fn = function() {
+  var _a, _b;
+  logger("handler: disconnect");
+  __privateGet(this, _provider).emit("disconnect");
+  (_b = (_a = __privateGet(this, _eventHandlers)) == null ? void 0 : _a.disconnect) == null ? void 0 : _b.call(_a);
+  __privateMethod(this, _MetamaskConnectEVM_instances, onAccountsChanged_fn).call(this, []);
+};
+attemptSessionRecovery_fn = function() {
+  return __async(this, null, function* () {
+    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: []
+      });
+      if (permittedChainIds.length && permittedAccounts.result) {
+        __privateMethod(this, _MetamaskConnectEVM_instances, onConnect_fn).call(this, {
+          chainId: permittedChainIds[0],
+          accounts: permittedAccounts.result
+        });
+      }
+    } catch (error) {
+      console.error("Error attempting session recovery", error);
+    }
+  });
+};
+function createMetamaskConnectEVM(options) {
+  return __async(this, null, function* () {
+    var _a;
+    enableDebug(options.debug);
+    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(
+        "supportedNetworks is required and must contain at least one chain configuration"
+      );
+    }
+    validSupportedChainsUrls(options.api.supportedNetworks, "supportedNetworks");
+    try {
+      const core = yield createMetamaskConnect(__spreadProps(__spreadValues({}, 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;
+    }
+  });
+}
+export {
+  createMetamaskConnectEVM,
+  getInfuraRpcUrls
+};
+//# sourceMappingURL=connect-evm.mjs.map