@metamask/connect-multichain 0.12.1 → 0.14.0

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

@@ -679,17 +679,94 @@ var init_ui = __esm({
 });
 
 // src/multichain/utils/analytics.ts
+function sanitiseErrorMessage(message) {
+  if (!message) {
+    return void 0;
+  }
+  let sanitised = message;
+  for (const { pattern, replacement } of SANITISE_PATTERNS) {
+    sanitised = sanitised.replace(pattern, replacement);
+  }
+  if (sanitised.length > ERROR_MESSAGE_SAMPLE_MAX_LENGTH) {
+    sanitised = `${sanitised.slice(0, ERROR_MESSAGE_SAMPLE_MAX_LENGTH - 1)}\u2026`;
+  }
+  return sanitised;
+}
+function getUnwrappedErrorDetails(error) {
+  var _a3, _b, _c, _d;
+  if (typeof error !== "object" || error === null) {
+    return { code: void 0, message: "" };
+  }
+  if (error instanceof RPCInvokeMethodErr) {
+    return {
+      code: (_a3 = error.rpcCode) != null ? _a3 : error.code,
+      message: (_c = (_b = error.rpcMessage) != null ? _b : error.message) != null ? _c : ""
+    };
+  }
+  const errorObj = error;
+  return {
+    code: errorObj.code,
+    message: (_d = errorObj.message) != null ? _d : ""
+  };
+}
 function isRejectionError(error) {
-  var _a3, _b;
   if (typeof error !== "object" || error === null) {
     return false;
   }
+  const { code, message } = getUnwrappedErrorDetails(error);
+  const errorMessage = message.toLowerCase();
+  return code === 4001 || errorMessage.includes("reject") || errorMessage.includes("denied") || errorMessage.includes("cancel") || // Narrow "user …" matches — bare "user" is too greedy (catches Account
+  // Abstraction errors like "user operation reverted").
+  errorMessage.includes("user rejected") || errorMessage.includes("user denied") || errorMessage.includes("user cancelled") || errorMessage.includes("user canceled");
+}
+function classifyFailureReason(error) {
+  var _a3, _b;
+  if (typeof error !== "object" || error === null) {
+    return "unknown";
+  }
   const errorObj = error;
-  const errorCode = errorObj.code;
-  const errorMessage = (_b = (_a3 = errorObj.message) == null ? void 0 : _a3.toLowerCase()) != null ? _b : "";
-  return errorCode === 4001 || // User rejected request (common EIP-1193 code)
-  errorCode === 4100 || // Unauthorized (common rejection code)
-  errorMessage.includes("reject") || errorMessage.includes("denied") || errorMessage.includes("cancel") || errorMessage.includes("user");
+  const errorName = (_a3 = errorObj.name) != null ? _a3 : "";
+  const errorMessageRaw = (_b = errorObj.message) != null ? _b : "";
+  const errorMessage = errorMessageRaw.toLowerCase();
+  const { code } = getUnwrappedErrorDetails(error);
+  if (typeof code === "number") {
+    if (code === -32601) {
+      return "wallet_method_unsupported";
+    }
+    if (code === -32602) {
+      return "wallet_invalid_params";
+    }
+    if (code === -32603) {
+      return "wallet_internal_error";
+    }
+    if (code <= -32e3 && code >= -32099) {
+      return "wallet_internal_error";
+    }
+    if (code === 4100) {
+      return "wallet_unauthorized";
+    }
+    if (code === 4200) {
+      return "wallet_method_unsupported";
+    }
+    if (code === 4902) {
+      return "unrecognized_chain";
+    }
+  }
+  if (errorName === "TransportTimeoutError" || errorMessageRaw === "Request timeout" || errorMessage.includes("timed out") || errorMessage.includes("timeout")) {
+    return "transport_timeout";
+  }
+  if (errorName === "TransportError" || errorMessage.includes("not connected") || errorMessage.includes("transport disconnect") || errorMessage.includes("connection lost") || errorMessage.includes("socket closed")) {
+    return "transport_disconnect";
+  }
+  return "unknown";
+}
+function extractErrorDiagnostics(error) {
+  const failureReason = classifyFailureReason(error);
+  const { code, message } = getUnwrappedErrorDetails(error);
+  const messageSample = sanitiseErrorMessage(message);
+  return __spreadValues(__spreadValues({
+    failure_reason: failureReason
+  }, typeof code === "number" ? { error_code: code } : {}), messageSample ? { error_message_sample: messageSample } : {});
 }
 function getBaseAnalyticsProperties(options, storage) {
   return __async(this, null, function* () {
@@ -705,26 +782,61 @@ function getBaseAnalyticsProperties(options, storage) {
     };
   });
 }
-function getWalletActionAnalyticsProperties(options, storage, invokeOptions, transportType) {
+function getWalletActionAnalyticsProperties(options, storage, invokeOptions, transportType, extra) {
   return __async(this, null, function* () {
     var _a3;
     const dappId = getDappId(options.dapp);
     const anonId = yield storage.getAnonId();
-    return {
+    return __spreadValues(__spreadValues(__spreadValues({
       mmconnect_versions: (_a3 = options.versions) != null ? _a3 : {},
       dapp_id: dappId,
       method: invokeOptions.request.method,
       caip_chain_id: invokeOptions.scope,
       anon_id: anonId,
       transport_type: transportType
-    };
+    }, (extra == null ? void 0 : extra.failure_reason) ? { failure_reason: extra.failure_reason } : {}), typeof (extra == null ? void 0 : extra.error_code) === "number" ? { error_code: extra.error_code } : {}), (extra == null ? void 0 : extra.error_message_sample) ? { error_message_sample: extra.error_message_sample } : {});
   });
 }
+var ERROR_MESSAGE_SAMPLE_MAX_LENGTH, SANITISE_PATTERNS;
 var init_analytics = __esm({
   "src/multichain/utils/analytics.ts"() {
     "use strict";
     init_utils2();
     init_domain();
+    ERROR_MESSAGE_SAMPLE_MAX_LENGTH = 200;
+    SANITISE_PATTERNS = [
+      // EVM-style 20-byte hex addresses (e.g. `0x` + 40 hex chars).
+      { pattern: /0x[a-fA-F0-9]{40}/gu, replacement: "<addr>" },
+      // Other long hex blobs: tx hashes, signatures, raw byte strings, large
+      // hex amounts. 16+ hex chars catches 32-byte hashes/signatures without
+      // snagging EVM method selectors (8 chars) or short hex codes.
+      { pattern: /(?:0x)?[a-fA-F0-9]{16,}/gu, replacement: "<hex>" },
+      // URLs of any scheme up to the first whitespace / quote / closing paren.
+      // Catches RPC endpoints, dapp deeplinks, query strings with secrets.
+      { pattern: /https?:\/\/[^\s"')]+/gu, replacement: "<url>" },
+      // Bech32 addresses: short HRP (1-10 lowercase chars) + `1` separator +
+      // ≥38 chars of Bech32 data alphabet `[ac-hj-np-z02-9]` (excludes the
+      // look-alike chars `b`, `i`, `o`, `1`). Covers Bitcoin SegWit
+      // (`bc1…`/`tb1…`) and Cosmos-SDK chains (`cosmos1…`, `osmo1…`,
+      // `juno1…`, `inj1…`, etc.) without enumerating every HRP. Runs before
+      // the Base58 pattern below — see header comment for why.
+      {
+        pattern: /\b[a-z]{1,10}1[ac-hj-np-z02-9]{38,}\b/gu,
+        replacement: "<addr>"
+      },
+      // Base58 tokens (32+ chars, Base58 alphabet `[1-9A-HJ-NP-Za-km-z]`).
+      // Covers Solana pubkeys (32-44 chars), Solana tx signatures (~88 chars),
+      // and Bitcoin Base58 addresses ≥32 chars. The 32-char floor and `\b`
+      // word boundary keep English words and shorter alphanumerics safe.
+      {
+        pattern: /\b[1-9A-HJ-NP-Za-km-z]{32,}\b/gu,
+        replacement: "<addr>"
+      },
+      // Long decimal numbers — token amounts, gas units, timestamps, lamports.
+      // 10+ digits catches typical chain quantities without affecting JSON-RPC
+      // codes (-32601, 4001, etc.) or short numeric IDs.
+      { pattern: /\d{10,}/gu, replacement: "<num>" }
+    ];
   }
 });
 
@@ -1024,1723 +1136,1754 @@ var init_utils2 = __esm({
   }
 });
 
-// src/ui/modals/base/utils.ts
-function formatRemainingTime(milliseconds) {
-  if (milliseconds <= 0) {
-    return "EXPIRED";
-  }
-  const seconds = Math.floor(milliseconds / 1e3);
-  return `${seconds}s`;
-}
-function shouldLogCountdown(remainingSeconds) {
-  if (remainingSeconds <= 10) {
-    return true;
-  } else if (remainingSeconds <= 30) {
-    return remainingSeconds % 5 === 0;
-  } else if (remainingSeconds <= 60) {
-    return remainingSeconds % 10 === 0;
-  } else if (remainingSeconds <= 300) {
-    return remainingSeconds % 30 === 0;
-  }
-  return remainingSeconds % 60 === 0;
-}
-var init_utils3 = __esm({
-  "src/ui/modals/base/utils.ts"() {
+// src/multichain/transports/constants.ts
+var MULTICHAIN_PROVIDER_STREAM_NAME;
+var init_constants2 = __esm({
+  "src/multichain/transports/constants.ts"() {
     "use strict";
+    MULTICHAIN_PROVIDER_STREAM_NAME = "metamask-multichain-provider";
   }
 });
 
-// src/ui/modals/base/AbstractInstallModal.ts
-var logger3, _expirationInterval, _lastLoggedCountdown, AbstractInstallModal;
-var init_AbstractInstallModal = __esm({
-  "src/ui/modals/base/AbstractInstallModal.ts"() {
+// src/multichain/transports/mwp/index.ts
+var mwp_exports = {};
+__export(mwp_exports, {
+  MWPTransport: () => MWPTransport
+});
+import {
+  TransportTimeoutError
+} from "@metamask/multichain-api-client";
+import { JsonRpcError, providerErrors as providerErrors2, rpcErrors } from "@metamask/rpc-errors";
+var DEFAULT_REQUEST_TIMEOUT2, CONNECTION_GRACE_PERIOD, DEFAULT_CONNECTION_TIMEOUT, DEFAULT_RESUME_TIMEOUT, SESSION_STORE_KEY, ACCOUNTS_STORE_KEY, CHAIN_STORE_KEY, PENDING_SESSION_REQUEST_KEY, CACHED_METHOD_LIST, CACHED_RESET_METHOD_LIST, logger, MWPTransport;
+var init_mwp = __esm({
+  "src/multichain/transports/mwp/index.ts"() {
     "use strict";
-    init_utils3();
     init_domain();
-    logger3 = createLogger("metamask-sdk:ui");
-    AbstractInstallModal = class extends Modal {
-      constructor() {
-        super(...arguments);
-        __privateAdd(this, _expirationInterval, null);
-        __privateAdd(this, _lastLoggedCountdown, -1);
+    init_utils2();
+    init_constants2();
+    DEFAULT_REQUEST_TIMEOUT2 = 60 * 1e3;
+    CONNECTION_GRACE_PERIOD = 60 * 1e3;
+    DEFAULT_CONNECTION_TIMEOUT = DEFAULT_REQUEST_TIMEOUT2 + CONNECTION_GRACE_PERIOD;
+    DEFAULT_RESUME_TIMEOUT = 10 * 1e3;
+    SESSION_STORE_KEY = "cache_wallet_getSession";
+    ACCOUNTS_STORE_KEY = "cache_eth_accounts";
+    CHAIN_STORE_KEY = "cache_eth_chainId";
+    PENDING_SESSION_REQUEST_KEY = "pending_session_request";
+    CACHED_METHOD_LIST = [
+      "wallet_getSession",
+      "wallet_createSession",
+      "wallet_sessionChanged"
+    ];
+    CACHED_RESET_METHOD_LIST = [
+      "wallet_revokeSession",
+      "wallet_revokePermissions"
+    ];
+    logger = createLogger("metamask-sdk:transport");
+    MWPTransport = class {
+      constructor(dappClient, kvstore, options = {
+        requestTimeout: DEFAULT_REQUEST_TIMEOUT2,
+        connectionTimeout: DEFAULT_CONNECTION_TIMEOUT,
+        resumeTimeout: DEFAULT_RESUME_TIMEOUT
+      }) {
+        this.dappClient = dappClient;
+        this.kvstore = kvstore;
+        this.options = options;
+        this.__pendingRequests = /* @__PURE__ */ new Map();
+        this.notificationCallbacks = /* @__PURE__ */ new Set();
+        this.dappClient.on("message", this.handleMessage.bind(this));
+        this.dappClient.on("session_request", (sessionRequest) => {
+          this.currentSessionRequest = sessionRequest;
+          this.kvstore.set(PENDING_SESSION_REQUEST_KEY, JSON.stringify(sessionRequest)).catch((err) => {
+            logger("Failed to store pending session request", err);
+          });
+        });
+        if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
+          this.windowFocusHandler = this.onWindowFocus.bind(this);
+          window.addEventListener("focus", this.windowFocusHandler);
+        }
       }
-      get link() {
-        return this.data;
+      get pendingRequests() {
+        return this.__pendingRequests;
       }
-      set link(link) {
-        this.data = link;
+      set pendingRequests(pendingRequests) {
+        this.__pendingRequests = pendingRequests;
       }
-      get connectionRequest() {
-        return this.options.connectionRequest;
+      get sessionRequest() {
+        return this.currentSessionRequest;
       }
-      set connectionRequest(connectionRequest) {
-        this.options.connectionRequest = connectionRequest;
+      /**
+       * Returns the stored pending session request from the dappClient session_request event, if any.
+       *
+       * @returns The stored SessionRequest, or null if none or invalid.
+       */
+      getStoredPendingSessionRequest() {
+        return __async(this, null, function* () {
+          try {
+            const raw = yield this.kvstore.get(PENDING_SESSION_REQUEST_KEY);
+            if (!raw) {
+              return null;
+            }
+            return JSON.parse(raw);
+          } catch (e) {
+            return null;
+          }
+        });
       }
-      updateLink(link) {
-        this.link = link;
-        if (this.instance) {
-          this.instance.link = link;
+      /**
+       * Removes the stored pending session request from the KVStore.
+       * This is necessary to ensure that ConnectMultichain is able to correctly
+       * infer the MWP Transport connection attempt status.
+       */
+      removeStoredPendingSessionRequest() {
+        return __async(this, null, function* () {
+          yield this.kvstore.delete(PENDING_SESSION_REQUEST_KEY);
+        });
+      }
+      onWindowFocus() {
+        if (!this.isConnected()) {
+          this.dappClient.reconnect();
         }
       }
-      updateExpiresIn(expiresIn) {
-        if (expiresIn >= 0 && this.instance) {
-          this.instance.expiresIn = expiresIn;
+      notifyCallbacks(data) {
+        this.notificationCallbacks.forEach((callback) => callback(data));
+      }
+      rejectRequest(id, error = new Error("Request rejected")) {
+        const request = this.pendingRequests.get(id);
+        if (request) {
+          this.pendingRequests.delete(id);
+          clearTimeout(request.timeout);
+          request.reject(error);
         }
       }
-      startExpirationCheck(connectionRequest) {
-        this.stopExpirationCheck();
-        let currentConnectionRequest = connectionRequest;
-        __privateSet(this, _expirationInterval, setInterval(() => __async(this, null, function* () {
-          const { sessionRequest } = currentConnectionRequest;
-          const now = Date.now();
-          const remainingMs = sessionRequest.expiresAt - now;
-          const remainingSeconds = Math.floor(remainingMs / 1e3);
-          if (remainingMs > 0 && shouldLogCountdown(remainingSeconds) && __privateGet(this, _lastLoggedCountdown) !== remainingSeconds) {
-            const formattedTime = formatRemainingTime(remainingMs);
-            logger3(
-              `[UI: InstallModal-nodejs()] QR code expires in: ${formattedTime} (${remainingSeconds}s)`
-            );
-            __privateSet(this, _lastLoggedCountdown, remainingSeconds);
+      parseWalletError(errorPayload) {
+        const errorData = errorPayload;
+        if (typeof errorData.code === "number" && typeof errorData.message === "string") {
+          const { code, message: message2 } = errorData;
+          if (code >= 1e3 && code <= 4999) {
+            return providerErrors2.custom({ code, message: message2 });
           }
-          if (now >= sessionRequest.expiresAt) {
-            this.stopExpirationCheck();
-            logger3(
-              "[UI: InstallModal-nodejs()] \u23F0 QR code EXPIRED! Generating new one..."
-            );
-            try {
-              currentConnectionRequest = yield this.options.createConnectionRequest();
-              const generateQRCode = yield this.options.generateQRCode(
-                currentConnectionRequest
+          return new JsonRpcError(code, message2);
+        }
+        const message = errorPayload instanceof Error ? errorPayload.message : JSON.stringify(errorPayload);
+        return rpcErrors.internal({ message });
+      }
+      handleMessage(message) {
+        if (typeof message === "object" && message !== null) {
+          if ("data" in message) {
+            const messagePayload = message.data;
+            if ("id" in messagePayload && typeof messagePayload.id === "string") {
+              const request = this.pendingRequests.get(messagePayload.id);
+              if (request) {
+                clearTimeout(request.timeout);
+                if ("error" in messagePayload && messagePayload.error) {
+                  this.pendingRequests.delete(messagePayload.id);
+                  request.reject(this.parseWalletError(messagePayload.error));
+                  return;
+                }
+                const requestWithName = __spreadProps(__spreadValues({}, messagePayload), {
+                  method: request.method === "wallet_getSession" || request.method === "wallet_createSession" ? "wallet_sessionChanged" : request.method
+                });
+                const notification = __spreadProps(__spreadValues({}, messagePayload), {
+                  method: request.method === "wallet_getSession" || request.method === "wallet_createSession" ? "wallet_sessionChanged" : request.method,
+                  params: requestWithName.result
+                });
+                this.notifyCallbacks(notification);
+                request.resolve(requestWithName);
+                this.pendingRequests.delete(messagePayload.id);
+              }
+            } else {
+              if (message.data.method === "metamask_chainChanged") {
+                this.kvstore.set(
+                  CHAIN_STORE_KEY,
+                  JSON.stringify(
+                    message.data.params.chainId
+                  )
+                );
+              }
+              if (message.data.method === "metamask_accountsChanged") {
+                this.kvstore.set(
+                  ACCOUNTS_STORE_KEY,
+                  JSON.stringify(
+                    message.data.params
+                  )
+                );
+              }
+              if (message.data.method === "wallet_sessionChanged") {
+                const notification = message.data;
+                const response = {
+                  result: notification.params
+                };
+                this.kvstore.set(SESSION_STORE_KEY, JSON.stringify(response));
+              }
+              this.notifyCallbacks(message.data);
+            }
+          }
+        }
+      }
+      onResumeSuccess(resumeResolve, resumeReject, options) {
+        return __async(this, null, function* () {
+          var _a3, _b, _c, _d, _e, _f, _g;
+          try {
+            yield this.waitForWalletSessionIfNotCached();
+            const sessionRequest = yield this.request({
+              method: "wallet_getSession"
+            });
+            if (sessionRequest.error) {
+              return resumeReject(new Error(sessionRequest.error.message));
+            }
+            let walletSession = sessionRequest.result;
+            if (walletSession && options) {
+              const currentScopes = Object.keys(
+                (_a3 = walletSession == null ? void 0 : walletSession.sessionScopes) != null ? _a3 : {}
               );
-              __privateSet(this, _lastLoggedCountdown, -1);
-              this.updateLink(generateQRCode);
-              this.updateExpiresIn(remainingSeconds);
-              this.renderQRCode(generateQRCode, currentConnectionRequest);
-            } catch (error) {
-              logger3(
-                `[UI: InstallModal-nodejs()] \u274C Error generating new QR code: ${error}`
+              const proposedScopes = (_b = options == null ? void 0 : options.scopes) != null ? _b : [];
+              const proposedCaipAccountIds = (_c = options == null ? void 0 : options.caipAccountIds) != null ? _c : [];
+              const hasSameScopesAndAccounts = isSameScopesAndAccounts(
+                currentScopes,
+                proposedScopes,
+                walletSession,
+                proposedCaipAccountIds
+              );
+              if (options.forceRequest || !hasSameScopesAndAccounts) {
+                const optionalScopes = addValidAccounts(
+                  getOptionalScopes((_d = options == null ? void 0 : options.scopes) != null ? _d : []),
+                  getValidAccounts((_e = options == null ? void 0 : options.caipAccountIds) != null ? _e : [])
+                );
+                const sessionRequest2 = {
+                  optionalScopes
+                };
+                const response = yield this.request({
+                  method: "wallet_createSession",
+                  params: sessionRequest2
+                });
+                if (response.error) {
+                  return resumeReject(new Error(response.error.message));
+                }
+                walletSession = response.result;
+              }
+            } else if (!walletSession) {
+              const optionalScopes = addValidAccounts(
+                getOptionalScopes((_f = options == null ? void 0 : options.scopes) != null ? _f : []),
+                getValidAccounts((_g = options == null ? void 0 : options.caipAccountIds) != null ? _g : [])
               );
+              const sessionRequest2 = { optionalScopes };
+              const response = yield this.request({
+                method: "wallet_createSession",
+                params: sessionRequest2
+              });
+              if (response.error) {
+                return resumeReject(new Error(response.error.message));
+              }
+              walletSession = response.result;
             }
+            yield this.removeStoredPendingSessionRequest();
+            this.notifyCallbacks({
+              method: "wallet_sessionChanged",
+              params: walletSession
+            });
+            return resumeResolve();
+          } catch (err) {
+            return resumeReject(err);
           }
-        }), 1e3));
-      }
-      stopExpirationCheck() {
-        if (__privateGet(this, _expirationInterval)) {
-          clearInterval(__privateGet(this, _expirationInterval));
-          __privateSet(this, _expirationInterval, null);
-          logger3(
-            "[UI: InstallModal-nodejs()] \u{1F6D1} Stopped QR code expiration checking"
-          );
-        }
+        });
       }
-    };
-    _expirationInterval = new WeakMap();
-    _lastLoggedCountdown = new WeakMap();
-  }
-});
-
-// src/ui/modals/web/install.ts
-var InstallModal;
-var init_install = __esm({
-  "src/ui/modals/web/install.ts"() {
-    "use strict";
-    init_AbstractInstallModal();
-    InstallModal = class extends AbstractInstallModal {
-      renderQRCode() {
+      init() {
+        return __async(this, null, function* () {
+        });
       }
-      mount() {
-        var _a3;
-        const { options } = this;
-        const modal = document.createElement(
-          "mm-install-modal"
-        );
-        modal.showInstallModal = options.showInstallModal;
-        modal.addEventListener("close", (ev) => {
-          const { detail } = ev;
-          options.onClose(detail == null ? void 0 : detail.shouldTerminate);
+      // TODO: Rename this
+      sendEip1193Message(payload, options) {
+        return __async(this, null, function* () {
+          const request = __spreadValues({
+            jsonrpc: "2.0",
+            id: String(getUniqueRequestId())
+          }, payload);
+          const cachedWalletSession = yield this.getCachedResponse(request);
+          if (cachedWalletSession) {
+            this.notifyCallbacks(cachedWalletSession);
+            return cachedWalletSession;
+          }
+          return new Promise((resolve, reject) => {
+            var _a3;
+            const timeout = setTimeout(() => {
+              this.rejectRequest(request.id, new TransportTimeoutError());
+            }, (_a3 = options == null ? void 0 : options.timeout) != null ? _a3 : this.options.requestTimeout);
+            this.pendingRequests.set(request.id, {
+              request,
+              method: request.method,
+              resolve: (response) => __async(this, null, function* () {
+                yield this.storeWalletSession(request, response);
+                return resolve(response);
+              }),
+              reject,
+              timeout
+            });
+            this.dappClient.sendRequest({
+              name: "metamask-provider",
+              data: request
+            }).catch(reject);
+          });
         });
-        modal.addEventListener(
-          "startDesktopOnboarding",
-          options.startDesktopOnboarding
-        );
-        modal.link = options.link;
-        this.instance = modal;
-        (_a3 = options.parentElement) == null ? void 0 : _a3.appendChild(modal);
-        this.startExpirationCheck(options.connectionRequest);
       }
-      unmount() {
-        var _a3;
-        const { options, instance: modal } = this;
-        this.stopExpirationCheck();
-        if (modal && ((_a3 = options.parentElement) == null ? void 0 : _a3.contains(modal))) {
-          options.parentElement.removeChild(modal);
-          this.instance = void 0;
-        }
+      connect(options) {
+        return __async(this, null, function* () {
+          const { dappClient } = this;
+          const session = yield this.getActiveSession();
+          if (session) {
+            logger("active session found", {
+              id: session.id,
+              channel: session.channel,
+              expiresAt: session.expiresAt
+            });
+          }
+          const storedSessionRequestBeforeConnectionAttempt = yield this.getStoredPendingSessionRequest();
+          let timeout;
+          let initialConnectionMessageHandler;
+          const connectionPromise = new Promise((resolve, reject) => __async(this, null, function* () {
+            let connection;
+            if (session) {
+              connection = new Promise((resumeResolve, resumeReject) => {
+                var _a3;
+                if (this.dappClient.state === "CONNECTED") {
+                  this.onResumeSuccess(resumeResolve, resumeReject, options);
+                } else {
+                  this.dappClient.once("connected", () => __async(this, null, function* () {
+                    this.onResumeSuccess(resumeResolve, resumeReject, options);
+                  }));
+                  dappClient.resume((_a3 = session == null ? void 0 : session.id) != null ? _a3 : "");
+                }
+              });
+            } else {
+              connection = new Promise(
+                (resolveConnection, rejectConnection) => {
+                  var _a3, _b;
+                  const optionalScopes = addValidAccounts(
+                    getOptionalScopes((_a3 = options == null ? void 0 : options.scopes) != null ? _a3 : []),
+                    getValidAccounts((_b = options == null ? void 0 : options.caipAccountIds) != null ? _b : [])
+                  );
+                  const sessionRequest = {
+                    optionalScopes,
+                    sessionProperties: options == null ? void 0 : options.sessionProperties
+                  };
+                  const request = {
+                    jsonrpc: "2.0",
+                    id: String(getUniqueRequestId()),
+                    method: "wallet_createSession",
+                    params: sessionRequest
+                  };
+                  initialConnectionMessageHandler = (message) => __async(this, null, function* () {
+                    if (typeof message !== "object" || message === null) {
+                      return;
+                    }
+                    if (!("data" in message)) {
+                      return;
+                    }
+                    const messagePayload = message.data;
+                    const isMatchingId = messagePayload.id === request.id;
+                    const isMatchingMethod = messagePayload.method === "wallet_createSession" || messagePayload.method === "wallet_sessionChanged";
+                    if (!isMatchingId && !isMatchingMethod) {
+                      return;
+                    }
+                    if (messagePayload.error) {
+                      return rejectConnection(
+                        this.parseWalletError(messagePayload.error)
+                      );
+                    }
+                    yield this.storeWalletSession(
+                      request,
+                      messagePayload
+                    );
+                    yield this.removeStoredPendingSessionRequest();
+                    this.notifyCallbacks(messagePayload);
+                    return resolveConnection();
+                  });
+                  this.dappClient.on("message", initialConnectionMessageHandler);
+                  const platformType = getPlatformType();
+                  const isQRCodeFlow = [
+                    "web-desktop" /* DesktopWeb */,
+                    "nodejs" /* NonBrowser */
+                  ].includes(platformType);
+                  const initialPayload = {
+                    name: MULTICHAIN_PROVIDER_STREAM_NAME,
+                    data: request
+                  };
+                  dappClient.connect({
+                    mode: "trusted",
+                    initialPayload: isQRCodeFlow ? void 0 : initialPayload
+                  }).then(() => __async(this, null, function* () {
+                    if (isQRCodeFlow) {
+                      return dappClient.sendRequest(initialPayload);
+                    }
+                    return void 0;
+                  })).catch((error) => {
+                    if (initialConnectionMessageHandler) {
+                      this.dappClient.off(
+                        "message",
+                        initialConnectionMessageHandler
+                      );
+                    }
+                    rejectConnection(error);
+                  });
+                }
+              );
+            }
+            timeout = setTimeout(
+              () => {
+                reject(new TransportTimeoutError());
+              },
+              storedSessionRequestBeforeConnectionAttempt ? this.options.resumeTimeout : this.options.connectionTimeout
+            );
+            connection.then(resolve).catch(reject);
+          }));
+          return connectionPromise.catch((error) => __async(this, null, function* () {
+            yield this.dappClient.disconnect();
+            throw error;
+          })).finally(() => {
+            if (timeout) {
+              clearTimeout(timeout);
+            }
+            if (initialConnectionMessageHandler) {
+              this.dappClient.off("message", initialConnectionMessageHandler);
+              initialConnectionMessageHandler = void 0;
+            }
+            this.removeStoredPendingSessionRequest();
+          });
+        });
       }
-    };
-  }
-});
-
-// src/ui/modals/base/AbstractOTPModal.ts
-var AbstractOTPCodeModal;
-var init_AbstractOTPModal = __esm({
-  "src/ui/modals/base/AbstractOTPModal.ts"() {
-    "use strict";
-    init_domain();
-    AbstractOTPCodeModal = class extends Modal {
-      get otpCode() {
-        return this.data;
-      }
-      set otpCode(code) {
-        this.data = code;
-      }
-      updateOTPCode(code) {
-        this.otpCode = code;
-        if (this.instance) {
-          this.instance.otpCode = code;
-        }
-      }
-    };
-  }
-});
-
-// src/ui/modals/web/otp.ts
-var OTPCodeModal;
-var init_otp = __esm({
-  "src/ui/modals/web/otp.ts"() {
-    "use strict";
-    init_AbstractOTPModal();
-    OTPCodeModal = class extends AbstractOTPCodeModal {
-      mount() {
+      /**
+       * Disconnects from the Mobile Wallet Protocol
+       *
+       * @param [scopes] - The scopes to revoke. If not provided or empty, all scopes will be revoked.
+       * @returns Nothing
+       */
+      disconnect() {
+        return __async(this, arguments, function* (scopes = []) {
+          var _a3, _b;
+          const cachedSession = yield this.getCachedResponse({
+            jsonrpc: "2.0",
+            id: "0",
+            method: "wallet_getSession"
+          });
+          const cachedSessionScopes = (_b = (_a3 = cachedSession == null ? void 0 : cachedSession.result) == null ? void 0 : _a3.sessionScopes) != null ? _b : {};
+          const remainingScopes = scopes.length === 0 ? [] : Object.keys(cachedSessionScopes).filter(
+            (scope) => !scopes.includes(scope)
+          );
+          const newSessionScopes = Object.fromEntries(
+            Object.entries(cachedSessionScopes).filter(
+              ([key]) => remainingScopes.includes(key)
+            )
+          );
+          this.request({ method: "wallet_revokeSession", params: { scopes } }).catch(
+            (err) => {
+              console.error("error revoking session", err);
+            }
+          );
+          const remainingScopesIncludeEip155 = remainingScopes.some(
+            (scope) => scope.includes("eip155")
+          );
+          if (!remainingScopesIncludeEip155) {
+            this.kvstore.delete(ACCOUNTS_STORE_KEY);
+            this.kvstore.delete(CHAIN_STORE_KEY);
+          }
+          if (remainingScopes.length > 0) {
+            this.kvstore.set(
+              SESSION_STORE_KEY,
+              JSON.stringify({
+                result: {
+                  sessionScopes: newSessionScopes
+                }
+              })
+            );
+          } else {
+            this.kvstore.delete(SESSION_STORE_KEY);
+            if (typeof window !== "undefined" && typeof window.removeEventListener !== "undefined" && this.windowFocusHandler) {
+              window.removeEventListener("focus", this.windowFocusHandler);
+              this.windowFocusHandler = void 0;
+            }
+            yield this.dappClient.disconnect();
+          }
+          this.notifyCallbacks({
+            method: "wallet_sessionChanged",
+            params: {
+              sessionScopes: newSessionScopes
+            }
+          });
+        });
       }
-      unmount() {
+      /**
+       * Checks if the transport is connected
+       *
+       * @returns True if transport is connected, false otherwise
+       */
+      isConnected() {
+        return this.dappClient.state === "CONNECTED";
       }
-    };
-  }
-});
-
-// src/ui/modals/web/index.ts
-var web_exports = {};
-__export(web_exports, {
-  InstallModal: () => InstallModal,
-  OTPCodeModal: () => OTPCodeModal
-});
-var init_web = __esm({
-  "src/ui/modals/web/index.ts"() {
-    "use strict";
-    init_install();
-    init_otp();
-  }
-});
-
-// src/store/adapters/web.ts
-var web_exports2 = {};
-__export(web_exports2, {
-  StoreAdapterWeb: () => StoreAdapterWeb
-});
-var _StoreAdapterWeb, StoreAdapterWeb;
-var init_web2 = __esm({
-  "src/store/adapters/web.ts"() {
-    "use strict";
-    init_domain();
-    _StoreAdapterWeb = class _StoreAdapterWeb extends StoreAdapter {
-      constructor(dbNameSuffix = "-kv-store", storeName = _StoreAdapterWeb.stores[0]) {
-        super();
-        this.storeName = storeName;
-        this.platform = "web";
-        const dbName = `${_StoreAdapterWeb.DB_NAME}${dbNameSuffix}`;
-        this.dbPromise = new Promise((resolve, reject) => {
+      /**
+       * Attempts to re-establish a connection via DappClient
+       *
+       * @returns Nothing
+       */
+      // TODO: We should re-evaluate adding this to the WebSocketTransport layer from `@metamask/mobile-wallet-protocol-core`
+      // ticket: https://consensyssoftware.atlassian.net/browse/WAPI-862
+      attemptResumeSession() {
+        return __async(this, null, function* () {
           try {
-            const request = this.internal.open(dbName, 1);
-            request.onerror = () => reject(new Error("Failed to open IndexedDB."));
-            request.onsuccess = () => resolve(request.result);
-            request.onupgradeneeded = () => {
-              const db = request.result;
-              for (const name of _StoreAdapterWeb.stores) {
-                if (!db.objectStoreNames.contains(name)) {
-                  db.createObjectStore(name);
-                }
+            yield this.dappClient.reconnect();
+            yield new Promise((resolve, reject) => {
+              const timeout = setTimeout(() => {
+                reject(new Error("Resume timeout"));
+              }, 2e3);
+              if (this.isConnected()) {
+                clearTimeout(timeout);
+                resolve();
+              } else {
+                this.dappClient.once("connected", () => {
+                  clearTimeout(timeout);
+                  resolve();
+                });
               }
-            };
+            });
           } catch (error) {
-            reject(error);
+            return Promise.reject(
+              new Error(`Failed to resume session: ${error.message}`)
+            );
           }
         });
       }
-      get internal() {
-        if (typeof window === "undefined" || !window.indexedDB) {
-          throw new Error("indexedDB is not available in this environment");
-        }
-        return window.indexedDB;
-      }
-      get(key) {
+      getCachedResponse(request) {
         return __async(this, null, function* () {
-          const { storeName } = this;
-          const db = yield this.dbPromise;
-          return new Promise((resolve, reject) => {
-            try {
-              const tx = db.transaction(storeName, "readonly");
-              const store = tx.objectStore(storeName);
-              const request = store.get(key);
-              request.onerror = () => reject(new Error("Failed to get value from IndexedDB."));
-              request.onsuccess = () => {
-                var _a3;
-                return resolve((_a3 = request.result) != null ? _a3 : null);
+          var _a3;
+          if (request.method === "wallet_getSession") {
+            const walletGetSession = yield this.kvstore.get(SESSION_STORE_KEY);
+            if (walletGetSession) {
+              const walletSession = JSON.parse(walletGetSession);
+              return {
+                id: request.id,
+                jsonrpc: "2.0",
+                result: (_a3 = walletSession.params) != null ? _a3 : walletSession.result,
+                // "what?... why walletSession.params?.."
+                method: request.method
               };
-            } catch (error) {
-              reject(error);
             }
-          });
+          } else if (request.method === "eth_accounts") {
+            const ethAccounts = yield this.kvstore.get(ACCOUNTS_STORE_KEY);
+            if (ethAccounts) {
+              return {
+                id: request.id,
+                jsonrpc: "2.0",
+                result: JSON.parse(ethAccounts),
+                method: request.method
+              };
+            }
+          } else if (request.method === "eth_chainId") {
+            const ethChainId = yield this.kvstore.get(CHAIN_STORE_KEY);
+            if (ethChainId) {
+              return {
+                id: request.id,
+                jsonrpc: "2.0",
+                result: JSON.parse(ethChainId),
+                method: request.method
+              };
+            }
+          }
         });
       }
-      set(key, value) {
+      storeWalletSession(request, response) {
         return __async(this, null, function* () {
-          const { storeName } = this;
-          const db = yield this.dbPromise;
+          if (response.error) {
+            return;
+          }
+          if (CACHED_METHOD_LIST.includes(request.method)) {
+            yield this.kvstore.set(SESSION_STORE_KEY, JSON.stringify(response));
+          } else if (request.method === "eth_accounts") {
+            yield this.kvstore.set(
+              ACCOUNTS_STORE_KEY,
+              JSON.stringify(response.result)
+            );
+          } else if (request.method === "eth_chainId") {
+            yield this.kvstore.set(CHAIN_STORE_KEY, JSON.stringify(response.result));
+          } else if (CACHED_RESET_METHOD_LIST.includes(request.method)) {
+            yield this.kvstore.delete(SESSION_STORE_KEY);
+            yield this.kvstore.delete(ACCOUNTS_STORE_KEY);
+            yield this.kvstore.delete(CHAIN_STORE_KEY);
+          }
+        });
+      }
+      request(payload, options) {
+        return __async(this, null, function* () {
+          const request = __spreadValues({
+            jsonrpc: "2.0",
+            id: String(getUniqueRequestId())
+          }, payload);
+          const cachedWalletSession = yield this.getCachedResponse(request);
+          if (cachedWalletSession) {
+            this.notifyCallbacks(cachedWalletSession);
+            return cachedWalletSession;
+          }
+          if (!this.isConnected()) {
+            yield this.attemptResumeSession();
+          }
           return new Promise((resolve, reject) => {
-            try {
-              const tx = db.transaction(storeName, "readwrite");
-              const store = tx.objectStore(storeName);
-              const request = store.put(value, key);
-              request.onerror = () => reject(new Error("Failed to set value in IndexedDB."));
-              request.onsuccess = () => resolve();
-            } catch (error) {
-              reject(error);
-            }
+            var _a3;
+            const timeout = setTimeout(() => {
+              this.rejectRequest(request.id, new TransportTimeoutError());
+            }, (_a3 = options == null ? void 0 : options.timeout) != null ? _a3 : this.options.requestTimeout);
+            this.pendingRequests.set(request.id, {
+              request,
+              method: request.method,
+              resolve: (response) => __async(this, null, function* () {
+                yield this.storeWalletSession(request, response);
+                return resolve(response);
+              }),
+              reject,
+              timeout
+            });
+            this.dappClient.sendRequest({
+              name: MULTICHAIN_PROVIDER_STREAM_NAME,
+              data: request
+            }).catch(reject);
           });
         });
       }
-      delete(key) {
+      onNotification(callback) {
+        this.notificationCallbacks.add(callback);
+        return () => {
+          this.notificationCallbacks.delete(callback);
+        };
+      }
+      getActiveSession() {
         return __async(this, null, function* () {
-          const { storeName } = this;
-          const db = yield this.dbPromise;
-          return new Promise((resolve, reject) => {
-            try {
-              const tx = db.transaction(storeName, "readwrite");
-              const store = tx.objectStore(storeName);
-              const request = store.delete(key);
-              request.onerror = () => reject(new Error("Failed to delete value from IndexedDB."));
-              request.onsuccess = () => resolve();
-            } catch (error) {
-              reject(error);
-            }
+          const { kvstore } = this;
+          const { SessionStore } = yield import("@metamask/mobile-wallet-protocol-core");
+          const sessionStore = yield SessionStore.create(kvstore);
+          try {
+            const [activeSession] = yield sessionStore.list();
+            return activeSession;
+          } catch (error) {
+            logger("error getting active session", error);
+            return void 0;
+          }
+        });
+      }
+      // This method checks if an existing CAIP session response is cached or waits for one
+      // to be received from the wallet if not cached. This is necessary because there is an edge
+      // case during the initial connection flow where after the user has accepted the permission approval
+      // and returned back to the dapp from the wallet, the dapp page may have gotten unloaded and refreshed.
+      // When it is unloaded and refreshed, it will try to resume the session by making a request for wallet_getSession
+      // which should resolve from cache, but because a race condition makes it possible for the response from the wallet
+      // for the initial wallet_createSession connection request to not have been handled and cached yet. This results
+      // in the wallet_getSession request never resolving unless we wait for it explicitly as done in this method.
+      waitForWalletSessionIfNotCached() {
+        return __async(this, null, function* () {
+          const cachedWalletGetSessionResponse = yield this.kvstore.get(SESSION_STORE_KEY);
+          if (cachedWalletGetSessionResponse) {
+            return;
+          }
+          let unsubscribe;
+          const responsePromise = new Promise((resolve) => {
+            unsubscribe = this.onNotification((message) => {
+              if (typeof message === "object" && message !== null) {
+                if ("data" in message) {
+                  const messagePayload = message.data;
+                  if (messagePayload.method === "wallet_getSession" || messagePayload.method === "wallet_sessionChanged") {
+                    unsubscribe();
+                    resolve();
+                  }
+                }
+              }
+            });
           });
+          const timeoutPromise = new Promise((_resolve, reject) => {
+            setTimeout(() => {
+              unsubscribe();
+              this.removeStoredPendingSessionRequest();
+              reject(new TransportTimeoutError());
+            }, this.options.resumeTimeout);
+          });
+          return Promise.race([responsePromise, timeoutPromise]);
         });
       }
     };
-    _StoreAdapterWeb.stores = ["sdk-kv-store", "key-value-pairs"];
-    _StoreAdapterWeb.DB_NAME = "mmconnect";
-    StoreAdapterWeb = _StoreAdapterWeb;
   }
 });
 
-// src/polyfills/buffer-shim.ts
-init_utils2();
-import { Buffer as Buffer2 } from "buffer";
-var globalObj = getGlobalObject();
-var _a;
-(_a = globalObj.Buffer) != null ? _a : globalObj.Buffer = Buffer2;
-
-// src/index.browser.ts
-init_domain();
-
-// src/multichain/index.ts
-import { analytics as analytics2 } from "@metamask/analytics";
-import {
-  ErrorCode,
-  ProtocolError,
-  SessionStore as SessionStore2,
-  WebSocketTransport
-} from "@metamask/mobile-wallet-protocol-core";
-import { DappClient } from "@metamask/mobile-wallet-protocol-dapp-client";
-import {
-  getMultichainClient
-} from "@metamask/multichain-api-client";
-
-// src/config/index.ts
-var MWP_RELAY_URL = "wss://mm-sdk-relay.api.cx.metamask.io/connection/websocket";
-var METAMASK_CONNECT_BASE_URL = "https://metamask.app.link/connect";
-var METAMASK_DEEPLINK_BASE = "metamask://connect";
-
-// src/multichain/index.ts
-init_domain();
-init_analytics();
-init_logger();
-init_multichain();
-init_platform();
-
-// src/multichain/rpc/handlers/rpcClient.ts
-init_domain();
-import fetch from "cross-fetch";
-var rpcId = 1;
-function getNextRpcId() {
-  rpcId += 1;
-  return rpcId;
+// src/multichain/transports/mwp/KeyManager.ts
+var KeyManager_exports = {};
+__export(KeyManager_exports, {
+  createKeyManager: () => createKeyManager
+});
+function createKeyManager() {
+  return __async(this, null, function* () {
+    const { decrypt, encrypt, PrivateKey, PublicKey } = yield import("eciesjs");
+    return {
+      generateKeyPair() {
+        const privateKey = new PrivateKey();
+        return {
+          privateKey: new Uint8Array(privateKey.secret),
+          publicKey: privateKey.publicKey.toBytes(true)
+        };
+      },
+      encrypt(plaintext, theirPublicKey) {
+        return __async(this, null, function* () {
+          const plaintextBuffer = Buffer.from(plaintext, "utf8");
+          const encryptedBuffer = encrypt(theirPublicKey, plaintextBuffer);
+          return encryptedBuffer.toString("base64");
+        });
+      },
+      decrypt(encryptedB64, myPrivateKey) {
+        return __async(this, null, function* () {
+          const encryptedBuffer = Buffer.from(encryptedB64, "base64");
+          const decryptedBuffer = yield decrypt(myPrivateKey, encryptedBuffer);
+          return Buffer.from(decryptedBuffer).toString("utf8");
+        });
+      },
+      validatePeerKey(key) {
+        PublicKey.fromHex(Buffer.from(key).toString("hex"));
+      }
+    };
+  });
 }
-var MissingRpcEndpointErr = class extends Error {
-};
-var RpcClient = class {
-  constructor(config, sdkInfo) {
-    this.config = config;
-    this.sdkInfo = sdkInfo;
+var init_KeyManager = __esm({
+  "src/multichain/transports/mwp/KeyManager.ts"() {
+    "use strict";
   }
-  /**
-   * Routes the request to a configured RPC node.
-   *
-   * @param options - The invoke method options.
-   * @returns The JSON response from the RPC node.
-   */
-  request(options) {
-    return __async(this, null, function* () {
-      const { request } = options;
-      const body = JSON.stringify({
-        jsonrpc: "2.0",
-        method: request.method,
-        params: request.params,
-        id: getNextRpcId()
-      });
-      const rpcEndpoint = this.getRpcEndpoint(options.scope);
-      const rpcRequest = yield this.fetchWithTimeout(
-        rpcEndpoint,
-        body,
-        "POST",
-        this.getHeaders(rpcEndpoint),
-        3e4
-      );
-      const response = yield this.parseResponse(rpcRequest);
-      return response;
-    });
+});
+
+// src/ui/modals/base/utils.ts
+function formatRemainingTime(milliseconds) {
+  if (milliseconds <= 0) {
+    return "EXPIRED";
   }
-  getRpcEndpoint(scope) {
-    var _a3, _b, _c;
-    const supportedNetworks = (_c = (_b = (_a3 = this.config) == null ? void 0 : _a3.api) == null ? void 0 : _b.supportedNetworks) != null ? _c : {};
-    const rpcEndpoint = supportedNetworks[scope];
-    if (!rpcEndpoint) {
-      throw new MissingRpcEndpointErr(
-        `No RPC endpoint found for scope ${scope}`
-      );
-    }
-    return rpcEndpoint;
+  const seconds = Math.floor(milliseconds / 1e3);
+  return `${seconds}s`;
+}
+function shouldLogCountdown(remainingSeconds) {
+  if (remainingSeconds <= 10) {
+    return true;
+  } else if (remainingSeconds <= 30) {
+    return remainingSeconds % 5 === 0;
+  } else if (remainingSeconds <= 60) {
+    return remainingSeconds % 10 === 0;
+  } else if (remainingSeconds <= 300) {
+    return remainingSeconds % 30 === 0;
   }
-  fetchWithTimeout(endpoint, body, method, headers, timeout) {
-    return __async(this, null, function* () {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), timeout);
-      try {
-        const response = yield fetch(endpoint, {
-          method,
-          headers,
-          body,
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-          throw new RPCHttpErr(endpoint, method, response.status);
-        }
-        return response;
-      } catch (error) {
-        clearTimeout(timeoutId);
-        if (error instanceof RPCHttpErr) {
-          throw error;
+  return remainingSeconds % 60 === 0;
+}
+var init_utils3 = __esm({
+  "src/ui/modals/base/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/ui/modals/base/AbstractInstallModal.ts
+var logger3, _expirationInterval, _lastLoggedCountdown, AbstractInstallModal;
+var init_AbstractInstallModal = __esm({
+  "src/ui/modals/base/AbstractInstallModal.ts"() {
+    "use strict";
+    init_utils3();
+    init_domain();
+    logger3 = createLogger("metamask-sdk:ui");
+    AbstractInstallModal = class extends Modal {
+      constructor() {
+        super(...arguments);
+        __privateAdd(this, _expirationInterval, null);
+        __privateAdd(this, _lastLoggedCountdown, -1);
+      }
+      get link() {
+        return this.data;
+      }
+      set link(link) {
+        this.data = link;
+      }
+      get connectionRequest() {
+        return this.options.connectionRequest;
+      }
+      set connectionRequest(connectionRequest) {
+        this.options.connectionRequest = connectionRequest;
+      }
+      updateLink(link) {
+        this.link = link;
+        if (this.instance) {
+          this.instance.link = link;
         }
-        if (error instanceof Error && error.name === "AbortError") {
-          throw new RPCReadonlyRequestErr(`Request timeout after ${timeout}ms`);
+      }
+      updateExpiresIn(expiresIn) {
+        if (expiresIn >= 0 && this.instance) {
+          this.instance.expiresIn = expiresIn;
         }
-        throw new RPCReadonlyRequestErr(error.message);
       }
-    });
-  }
-  parseResponse(response) {
-    return __async(this, null, function* () {
-      try {
-        const rpcResponse = yield response.json();
-        return rpcResponse.result;
-      } catch (error) {
-        throw new RPCReadonlyResponseErr(error.message);
+      startExpirationCheck(connectionRequest) {
+        this.stopExpirationCheck();
+        let currentConnectionRequest = connectionRequest;
+        __privateSet(this, _expirationInterval, setInterval(() => __async(this, null, function* () {
+          const { sessionRequest } = currentConnectionRequest;
+          const now = Date.now();
+          const remainingMs = sessionRequest.expiresAt - now;
+          const remainingSeconds = Math.floor(remainingMs / 1e3);
+          if (remainingMs > 0 && shouldLogCountdown(remainingSeconds) && __privateGet(this, _lastLoggedCountdown) !== remainingSeconds) {
+            const formattedTime = formatRemainingTime(remainingMs);
+            logger3(
+              `[UI: InstallModal-nodejs()] QR code expires in: ${formattedTime} (${remainingSeconds}s)`
+            );
+            __privateSet(this, _lastLoggedCountdown, remainingSeconds);
+          }
+          if (now >= sessionRequest.expiresAt) {
+            this.stopExpirationCheck();
+            logger3(
+              "[UI: InstallModal-nodejs()] \u23F0 QR code EXPIRED! Generating new one..."
+            );
+            try {
+              currentConnectionRequest = yield this.options.createConnectionRequest();
+              const generateQRCode = yield this.options.generateQRCode(
+                currentConnectionRequest
+              );
+              __privateSet(this, _lastLoggedCountdown, -1);
+              this.updateLink(generateQRCode);
+              this.updateExpiresIn(remainingSeconds);
+              this.renderQRCode(generateQRCode, currentConnectionRequest);
+            } catch (error) {
+              logger3(
+                `[UI: InstallModal-nodejs()] \u274C Error generating new QR code: ${error}`
+              );
+            }
+          }
+        }), 1e3));
+      }
+      stopExpirationCheck() {
+        if (__privateGet(this, _expirationInterval)) {
+          clearInterval(__privateGet(this, _expirationInterval));
+          __privateSet(this, _expirationInterval, null);
+          logger3(
+            "[UI: InstallModal-nodejs()] \u{1F6D1} Stopped QR code expiration checking"
+          );
+        }
       }
-    });
-  }
-  getHeaders(rpcEndpoint) {
-    const defaultHeaders = {
-      Accept: "application/json",
-      "Content-Type": "application/json"
     };
-    if (rpcEndpoint.includes("infura")) {
-      return __spreadProps(__spreadValues({}, defaultHeaders), {
-        "Metamask-Sdk-Info": this.sdkInfo
-      });
-    }
-    return defaultHeaders;
+    _expirationInterval = new WeakMap();
+    _lastLoggedCountdown = new WeakMap();
   }
-};
+});
 
-// src/multichain/rpc/requestRouter.ts
-import { analytics } from "@metamask/analytics";
-init_domain();
-init_utils2();
-init_analytics();
-var _RequestRouter_instances, withAnalyticsTracking_fn, trackWalletActionRequested_fn, trackWalletActionSucceeded_fn, trackWalletActionFailed_fn, trackWalletActionRejected_fn;
-var RequestRouter = class {
-  constructor(transport, rpcClient, config, transportType) {
-    this.transport = transport;
-    this.rpcClient = rpcClient;
-    this.config = config;
-    this.transportType = transportType;
-    __privateAdd(this, _RequestRouter_instances);
-  }
-  /**
-   * The main entry point for invoking an RPC method.
-   * This method acts as a router, determining the correct handling strategy
-   * for the request and delegating to the appropriate private handler.
-   *
-   * @param options
-   */
-  invokeMethod(options) {
-    return __async(this, null, function* () {
-      const { method } = options.request;
-      if (RPC_HANDLED_METHODS.has(method)) {
-        return this.handleWithRpcNode(options);
+// src/ui/modals/web/install.ts
+var InstallModal;
+var init_install = __esm({
+  "src/ui/modals/web/install.ts"() {
+    "use strict";
+    init_AbstractInstallModal();
+    InstallModal = class extends AbstractInstallModal {
+      renderQRCode() {
       }
-      if (SDK_HANDLED_METHODS.has(method)) {
-        return this.handleWithSdkState(options);
+      mount() {
+        var _a3;
+        const { options } = this;
+        const modal = document.createElement(
+          "mm-install-modal"
+        );
+        modal.showInstallModal = options.showInstallModal;
+        modal.addEventListener("close", (ev) => {
+          const { detail } = ev;
+          options.onClose(detail == null ? void 0 : detail.shouldTerminate);
+        });
+        modal.addEventListener(
+          "startDesktopOnboarding",
+          options.startDesktopOnboarding
+        );
+        modal.link = options.link;
+        this.instance = modal;
+        (_a3 = options.parentElement) == null ? void 0 : _a3.appendChild(modal);
+        this.startExpirationCheck(options.connectionRequest);
       }
-      return this.handleWithWallet(options);
-    });
+      unmount() {
+        var _a3;
+        const { options, instance: modal } = this;
+        this.stopExpirationCheck();
+        if (modal && ((_a3 = options.parentElement) == null ? void 0 : _a3.contains(modal))) {
+          options.parentElement.removeChild(modal);
+          this.instance = void 0;
+        }
+      }
+    };
   }
-  /**
-   * Forwards the request directly to the wallet via the transport.
-   *
-   * @param options
-   */
-  handleWithWallet(options) {
-    return __async(this, null, function* () {
-      return __privateMethod(this, _RequestRouter_instances, withAnalyticsTracking_fn).call(this, options, () => __async(this, null, function* () {
-        const request = this.transport.request({
-          method: "wallet_invokeMethod",
-          params: options
-        });
-        const { ui, mobile } = this.config;
-        const { showInstallModal = false } = ui != null ? ui : {};
-        const secure = isSecure();
-        const shouldOpenDeeplink = secure && !showInstallModal;
-        if (shouldOpenDeeplink) {
-          setTimeout(() => __async(this, null, function* () {
-            const session = yield this.transport.getActiveSession();
-            if (!session) {
-              throw new Error("No active session found");
-            }
-            const url = `${METAMASK_DEEPLINK_BASE}/mwp?id=${encodeURIComponent(session.id)}`;
-            if (mobile == null ? void 0 : mobile.preferredOpenLink) {
-              mobile.preferredOpenLink(url, "_self");
-            } else {
-              openDeeplink(this.config, url, METAMASK_CONNECT_BASE_URL);
-            }
-          }), 10);
-        }
-        const response = yield request;
-        if (response.error) {
-          const { error } = response;
-          throw new RPCInvokeMethodErr(
-            `RPC Request failed with code ${error.code}: ${error.message}`,
-            error.code,
-            error.message
-          );
-        }
-        return response.result;
-      }));
-    });
-  }
-  /**
-   * Routes the request to a configured RPC node.
-   *
-   * @param options
-   */
-  handleWithRpcNode(options) {
-    return __async(this, null, function* () {
-      try {
-        return yield this.rpcClient.request(options);
-      } catch (error) {
-        if (error instanceof MissingRpcEndpointErr) {
-          return this.handleWithWallet(options);
+});
+
+// src/ui/modals/base/AbstractOTPModal.ts
+var AbstractOTPCodeModal;
+var init_AbstractOTPModal = __esm({
+  "src/ui/modals/base/AbstractOTPModal.ts"() {
+    "use strict";
+    init_domain();
+    AbstractOTPCodeModal = class extends Modal {
+      get otpCode() {
+        return this.data;
+      }
+      set otpCode(code) {
+        this.data = code;
+      }
+      updateOTPCode(code) {
+        this.otpCode = code;
+        if (this.instance) {
+          this.instance.otpCode = code;
         }
-        throw error;
       }
-    });
-  }
-  /**
-   * Responds directly from the SDK's session state.
-   *
-   * @param options
-   */
-  handleWithSdkState(options) {
-    return __async(this, null, function* () {
-      console.warn(
-        `Method "${options.request.method}" is configured for SDK state handling, but this is not yet implemented. Falling back to wallet passthrough.`
-      );
-      return this.handleWithWallet(options);
-    });
+    };
   }
-};
-_RequestRouter_instances = new WeakSet();
-withAnalyticsTracking_fn = function(options, execute) {
-  return __async(this, null, function* () {
-    var _a3;
-    yield __privateMethod(this, _RequestRouter_instances, trackWalletActionRequested_fn).call(this, options);
-    try {
-      const result = yield execute();
-      yield __privateMethod(this, _RequestRouter_instances, trackWalletActionSucceeded_fn).call(this, options);
-      return result;
-    } catch (error) {
-      const isRejection = isRejectionError(error);
-      if (isRejection) {
-        yield __privateMethod(this, _RequestRouter_instances, trackWalletActionRejected_fn).call(this, options);
-      } else {
-        yield __privateMethod(this, _RequestRouter_instances, trackWalletActionFailed_fn).call(this, options);
+});
+
+// src/ui/modals/web/otp.ts
+var OTPCodeModal;
+var init_otp = __esm({
+  "src/ui/modals/web/otp.ts"() {
+    "use strict";
+    init_AbstractOTPModal();
+    OTPCodeModal = class extends AbstractOTPCodeModal {
+      mount() {
       }
-      if (error instanceof RPCInvokeMethodErr) {
-        throw error;
+      unmount() {
       }
-      const castError = error;
-      throw new RPCInvokeMethodErr(
-        (_a3 = castError.message) != null ? _a3 : "Unknown error",
-        castError.code
-      );
-    }
-  });
-};
-trackWalletActionRequested_fn = function(options) {
-  return __async(this, null, function* () {
-    const props = yield getWalletActionAnalyticsProperties(
-      this.config,
-      this.config.storage,
-      options,
-      this.transportType
-    );
-    analytics.track("mmconnect_wallet_action_requested", props);
-  });
-};
-trackWalletActionSucceeded_fn = function(options) {
-  return __async(this, null, function* () {
-    const props = yield getWalletActionAnalyticsProperties(
-      this.config,
-      this.config.storage,
-      options,
-      this.transportType
-    );
-    analytics.track("mmconnect_wallet_action_succeeded", props);
-  });
-};
-trackWalletActionFailed_fn = function(options) {
-  return __async(this, null, function* () {
-    const props = yield getWalletActionAnalyticsProperties(
-      this.config,
-      this.config.storage,
-      options,
-      this.transportType
-    );
-    analytics.track("mmconnect_wallet_action_failed", props);
-  });
-};
-trackWalletActionRejected_fn = function(options) {
-  return __async(this, null, function* () {
-    const props = yield getWalletActionAnalyticsProperties(
-      this.config,
-      this.config.storage,
-      options,
-      this.transportType
-    );
-    analytics.track("mmconnect_wallet_action_rejected", props);
-  });
-};
+    };
+  }
+});
 
-// src/multichain/transports/default/index.ts
-init_utils2();
-import {
-  getDefaultTransport
-} from "@metamask/multichain-api-client";
-var DEFAULT_REQUEST_TIMEOUT = 60 * 1e3;
-var _notificationCallbacks, _transport, _defaultRequestOptions, _pendingRequests, _handleResponseListener, _handleNotificationListener, _DefaultTransport_instances, notifyCallbacks_fn, isMetamaskProviderEvent_fn, handleResponse_fn, handleNotification_fn, setupMessageListener_fn, init_fn;
-var DefaultTransport = class {
-  constructor() {
-    __privateAdd(this, _DefaultTransport_instances);
-    __privateAdd(this, _notificationCallbacks, /* @__PURE__ */ new Set());
-    __privateAdd(this, _transport, getDefaultTransport());
-    __privateAdd(this, _defaultRequestOptions, {
-      timeout: DEFAULT_REQUEST_TIMEOUT
-    });
-    __privateAdd(this, _pendingRequests, /* @__PURE__ */ new Map());
-    __privateAdd(this, _handleResponseListener);
-    __privateAdd(this, _handleNotificationListener);
+// src/ui/modals/web/index.ts
+var web_exports = {};
+__export(web_exports, {
+  InstallModal: () => InstallModal,
+  OTPCodeModal: () => OTPCodeModal
+});
+var init_web = __esm({
+  "src/ui/modals/web/index.ts"() {
+    "use strict";
+    init_install();
+    init_otp();
   }
-  sendEip1193Message(payload, options) {
-    return __async(this, null, function* () {
-      __privateMethod(this, _DefaultTransport_instances, setupMessageListener_fn).call(this);
-      const requestId = String(getUniqueRequestId());
-      const request = __spreadValues({
-        jsonrpc: "2.0",
-        id: requestId
-      }, payload);
-      return new Promise((resolve, reject) => {
-        var _a3;
-        const timeout = setTimeout(() => {
-          __privateGet(this, _pendingRequests).delete(requestId);
-          reject(new Error("Request timeout"));
-        }, (_a3 = options == null ? void 0 : options.timeout) != null ? _a3 : __privateGet(this, _defaultRequestOptions).timeout);
-        __privateGet(this, _pendingRequests).set(requestId, {
-          resolve: (response) => {
-            resolve(response);
-          },
-          reject,
-          timeout
+});
+
+// src/store/adapters/web.ts
+var web_exports2 = {};
+__export(web_exports2, {
+  StoreAdapterWeb: () => StoreAdapterWeb
+});
+var _StoreAdapterWeb, StoreAdapterWeb;
+var init_web2 = __esm({
+  "src/store/adapters/web.ts"() {
+    "use strict";
+    init_domain();
+    _StoreAdapterWeb = class _StoreAdapterWeb extends StoreAdapter {
+      constructor(dbNameSuffix = "-kv-store", storeName = _StoreAdapterWeb.stores[0]) {
+        super();
+        this.storeName = storeName;
+        this.platform = "web";
+        const dbName = `${_StoreAdapterWeb.DB_NAME}${dbNameSuffix}`;
+        this.dbPromise = new Promise((resolve, reject) => {
+          try {
+            const request = this.internal.open(dbName, 1);
+            request.onerror = () => reject(new Error("Failed to open IndexedDB."));
+            request.onsuccess = () => resolve(request.result);
+            request.onupgradeneeded = () => {
+              const db = request.result;
+              for (const name of _StoreAdapterWeb.stores) {
+                if (!db.objectStoreNames.contains(name)) {
+                  db.createObjectStore(name);
+                }
+              }
+            };
+          } catch (error) {
+            reject(error);
+          }
         });
-        window.postMessage(
-          {
-            target: "metamask-contentscript",
-            data: {
-              name: "metamask-provider",
-              data: request
-            }
-          },
-          // eslint-disable-next-line no-restricted-globals
-          location.origin
-        );
-      });
-    });
-  }
-  init() {
-    return __async(this, null, function* () {
-      yield __privateMethod(this, _DefaultTransport_instances, init_fn).call(this);
-      let walletSession = { sessionScopes: {} };
-      try {
-        const sessionRequest = yield this.request(
-          { method: "wallet_getSession" },
-          __privateGet(this, _defaultRequestOptions)
-        );
-        walletSession = sessionRequest.result;
-      } catch (e) {
-        console.error(
-          "Failed to get wallet session during DefaultTransport init"
-        );
       }
-      __privateMethod(this, _DefaultTransport_instances, notifyCallbacks_fn).call(this, {
-        method: "wallet_sessionChanged",
-        params: walletSession
-      });
-    });
-  }
-  connect(options) {
-    return __async(this, null, function* () {
-      var _a3, _b, _c, _d, _e;
-      yield __privateMethod(this, _DefaultTransport_instances, init_fn).call(this);
-      const sessionRequest = yield this.request(
-        { method: "wallet_getSession" },
-        __privateGet(this, _defaultRequestOptions)
-      );
-      if (sessionRequest.error) {
-        throw new Error(sessionRequest.error.message);
-      }
-      let walletSession = sessionRequest.result;
-      const createSessionParams = {
-        optionalScopes: addValidAccounts(
-          getOptionalScopes((_a3 = options == null ? void 0 : options.scopes) != null ? _a3 : []),
-          getValidAccounts((_b = options == null ? void 0 : options.caipAccountIds) != null ? _b : [])
-        ),
-        sessionProperties: options == null ? void 0 : options.sessionProperties
-      };
-      if (walletSession && options && !options.forceRequest) {
-        const currentScopes = Object.keys(
-          (_c = walletSession == null ? void 0 : walletSession.sessionScopes) != null ? _c : {}
-        );
-        const proposedScopes = (_d = options == null ? void 0 : options.scopes) != null ? _d : [];
-        const proposedCaipAccountIds = (_e = options == null ? void 0 : options.caipAccountIds) != null ? _e : [];
-        const hasSameScopesAndAccounts = isSameScopesAndAccounts(
-          currentScopes,
-          proposedScopes,
-          walletSession,
-          proposedCaipAccountIds
-        );
-        if (!hasSameScopesAndAccounts) {
-          const response = yield this.request(
-            { method: "wallet_createSession", params: createSessionParams },
-            __privateGet(this, _defaultRequestOptions)
-          );
-          if (response.error) {
-            throw new Error(response.error.message);
-          }
-          walletSession = response.result;
-        }
-      } else if (!walletSession || (options == null ? void 0 : options.forceRequest)) {
-        const response = yield this.request(
-          { method: "wallet_createSession", params: createSessionParams },
-          __privateGet(this, _defaultRequestOptions)
-        );
-        if (response.error) {
-          throw new Error(response.error.message);
+      get internal() {
+        if (typeof window === "undefined" || !window.indexedDB) {
+          throw new Error("indexedDB is not available in this environment");
         }
-        walletSession = response.result;
+        return window.indexedDB;
       }
-      __privateMethod(this, _DefaultTransport_instances, notifyCallbacks_fn).call(this, {
-        method: "wallet_sessionChanged",
-        params: walletSession
-      });
-    });
-  }
-  disconnect() {
-    return __async(this, arguments, function* (scopes = []) {
-      yield this.request({ method: "wallet_revokeSession", params: { scopes } });
-    });
-  }
-  isConnected() {
-    return __privateGet(this, _transport).isConnected();
-  }
-  request(_0) {
-    return __async(this, arguments, function* (request, options = __privateGet(this, _defaultRequestOptions)) {
-      return __privateGet(this, _transport).request(request, options);
-    });
-  }
-  onNotification(callback) {
-    __privateGet(this, _transport).onNotification(callback);
-    __privateGet(this, _notificationCallbacks).add(callback);
-    return () => {
-      __privateGet(this, _notificationCallbacks).delete(callback);
-    };
-  }
-  getActiveSession() {
-    return __async(this, null, function* () {
-      throw new Error(
-        "getActiveSession is purposely not implemented for the DefaultTransport"
-      );
-    });
-  }
-  getStoredPendingSessionRequest() {
-    return __async(this, null, function* () {
-      throw new Error(
-        "getStoredPendingSessionRequest is purposely not implemented for the DefaultTransport"
-      );
-    });
-  }
-};
-_notificationCallbacks = new WeakMap();
-_transport = new WeakMap();
-_defaultRequestOptions = new WeakMap();
-_pendingRequests = new WeakMap();
-_handleResponseListener = new WeakMap();
-_handleNotificationListener = new WeakMap();
-_DefaultTransport_instances = new WeakSet();
-notifyCallbacks_fn = function(data) {
-  for (const callback of __privateGet(this, _notificationCallbacks)) {
-    try {
-      callback(data);
-    } catch (error) {
-      console.log(
-        "[WindowPostMessageTransport] notifyCallbacks error:",
-        error
-      );
-    }
-  }
-};
-isMetamaskProviderEvent_fn = function(event) {
-  var _a3, _b;
-  return ((_b = (_a3 = event == null ? void 0 : event.data) == null ? void 0 : _a3.data) == null ? void 0 : _b.name) === "metamask-provider" && // eslint-disable-next-line no-restricted-globals
-  event.origin === location.origin;
-};
-handleResponse_fn = function(event) {
-  var _a3, _b;
-  if (!__privateMethod(this, _DefaultTransport_instances, isMetamaskProviderEvent_fn).call(this, event)) {
-    return;
-  }
-  const responseData = (_b = (_a3 = event == null ? void 0 : event.data) == null ? void 0 : _a3.data) == null ? void 0 : _b.data;
-  if (typeof responseData === "object" && responseData !== null && "method" in responseData) {
-    return;
-  }
-  if (typeof responseData === "object" && responseData !== null && "id" in responseData && ("result" in responseData || "error" in responseData)) {
-    const responseId = String(responseData.id);
-    const pendingRequest = __privateGet(this, _pendingRequests).get(responseId);
-    if (pendingRequest) {
-      clearTimeout(pendingRequest.timeout);
-      __privateGet(this, _pendingRequests).delete(responseId);
-      const response = responseData;
-      if ("error" in response && response.error) {
-        const error = new Error(
-          response.error.message || "Request failed"
-        );
-        if (typeof response.error.code === "number") {
-          error.code = response.error.code;
-        }
-        pendingRequest.reject(error);
-      } else {
-        pendingRequest.resolve(response);
+      get(key) {
+        return __async(this, null, function* () {
+          const { storeName } = this;
+          const db = yield this.dbPromise;
+          return new Promise((resolve, reject) => {
+            try {
+              const tx = db.transaction(storeName, "readonly");
+              const store = tx.objectStore(storeName);
+              const request = store.get(key);
+              request.onerror = () => reject(new Error("Failed to get value from IndexedDB."));
+              request.onsuccess = () => {
+                var _a3;
+                return resolve((_a3 = request.result) != null ? _a3 : null);
+              };
+            } catch (error) {
+              reject(error);
+            }
+          });
+        });
       }
-    }
-  }
-};
-handleNotification_fn = function(event) {
-  var _a3, _b;
-  if (!__privateMethod(this, _DefaultTransport_instances, isMetamaskProviderEvent_fn).call(this, event)) {
-    return;
-  }
-  const responseData = (_b = (_a3 = event == null ? void 0 : event.data) == null ? void 0 : _a3.data) == null ? void 0 : _b.data;
-  if (typeof responseData === "object" && responseData !== null && "method" in responseData) {
-    __privateMethod(this, _DefaultTransport_instances, notifyCallbacks_fn).call(this, responseData);
-  }
-};
-setupMessageListener_fn = function() {
-  if (__privateGet(this, _handleResponseListener)) {
-    return;
+      set(key, value) {
+        return __async(this, null, function* () {
+          const { storeName } = this;
+          const db = yield this.dbPromise;
+          return new Promise((resolve, reject) => {
+            try {
+              const tx = db.transaction(storeName, "readwrite");
+              const store = tx.objectStore(storeName);
+              const request = store.put(value, key);
+              request.onerror = () => reject(new Error("Failed to set value in IndexedDB."));
+              request.onsuccess = () => resolve();
+            } catch (error) {
+              reject(error);
+            }
+          });
+        });
+      }
+      delete(key) {
+        return __async(this, null, function* () {
+          const { storeName } = this;
+          const db = yield this.dbPromise;
+          return new Promise((resolve, reject) => {
+            try {
+              const tx = db.transaction(storeName, "readwrite");
+              const store = tx.objectStore(storeName);
+              const request = store.delete(key);
+              request.onerror = () => reject(new Error("Failed to delete value from IndexedDB."));
+              request.onsuccess = () => resolve();
+            } catch (error) {
+              reject(error);
+            }
+          });
+        });
+      }
+    };
+    _StoreAdapterWeb.stores = ["sdk-kv-store", "key-value-pairs"];
+    _StoreAdapterWeb.DB_NAME = "mmconnect";
+    StoreAdapterWeb = _StoreAdapterWeb;
   }
-  __privateSet(this, _handleResponseListener, __privateMethod(this, _DefaultTransport_instances, handleResponse_fn).bind(this));
-  __privateSet(this, _handleNotificationListener, __privateMethod(this, _DefaultTransport_instances, handleNotification_fn).bind(this));
-  window.addEventListener("message", __privateGet(this, _handleResponseListener));
-  window.addEventListener("message", __privateGet(this, _handleNotificationListener));
-};
-init_fn = function() {
-  return __async(this, null, function* () {
-    __privateMethod(this, _DefaultTransport_instances, setupMessageListener_fn).call(this);
-    if (!__privateGet(this, _transport).isConnected()) {
-      yield __privateGet(this, _transport).connect();
-    }
-  });
-};
+});
 
-// src/multichain/transports/multichainApiClientWrapper/index.ts
+// src/polyfills/buffer-shim.ts
 init_utils2();
-import { providerErrors } from "@metamask/rpc-errors";
-var _notificationCallbacks2, _MultichainApiClientWrapperTransport_instances, walletCreateSession_fn, walletGetSession_fn, walletRevokeSession_fn, walletInvokeMethod_fn;
-var MultichainApiClientWrapperTransport = class {
-  constructor(metamaskConnectMultichain) {
-    this.metamaskConnectMultichain = metamaskConnectMultichain;
-    __privateAdd(this, _MultichainApiClientWrapperTransport_instances);
-    __privateAdd(this, _notificationCallbacks2, /* @__PURE__ */ new Set());
-  }
-  isTransportDefined() {
-    try {
-      return Boolean(this.metamaskConnectMultichain.transport);
-    } catch (_error) {
-      return false;
-    }
-  }
-  clearNotificationCallbacks() {
-    __privateGet(this, _notificationCallbacks2).clear();
+import { Buffer as Buffer2 } from "buffer";
+var globalObj = getGlobalObject();
+var _a;
+(_a = globalObj.Buffer) != null ? _a : globalObj.Buffer = Buffer2;
+
+// src/index.browser.ts
+init_domain();
+
+// src/multichain/index.ts
+import { analytics as analytics2 } from "@metamask/analytics";
+import {
+  getMultichainClient
+} from "@metamask/multichain-api-client";
+
+// src/config/index.ts
+var MWP_RELAY_URL = "wss://mm-sdk-relay.api.cx.metamask.io/connection/websocket";
+var METAMASK_CONNECT_BASE_URL = "https://metamask.app.link/connect";
+var METAMASK_DEEPLINK_BASE = "metamask://connect";
+
+// src/multichain/index.ts
+init_domain();
+init_analytics();
+init_logger();
+init_multichain();
+init_platform();
+
+// src/multichain/rpc/handlers/rpcClient.ts
+init_domain();
+import fetch from "cross-fetch";
+var rpcId = 1;
+function getNextRpcId() {
+  rpcId += 1;
+  return rpcId;
+}
+var MissingRpcEndpointErr = class extends Error {
+};
+var RpcClient = class {
+  constructor(config, sdkInfo) {
+    this.config = config;
+    this.sdkInfo = sdkInfo;
   }
-  notifyCallbacks(data) {
-    __privateGet(this, _notificationCallbacks2).forEach((callback) => {
-      callback(data);
+  /**
+   * Routes the request to a configured RPC node.
+   *
+   * @param options - The invoke method options.
+   * @returns The JSON response from the RPC node.
+   */
+  request(options) {
+    return __async(this, null, function* () {
+      const { request } = options;
+      const body = JSON.stringify({
+        jsonrpc: "2.0",
+        method: request.method,
+        params: request.params,
+        id: getNextRpcId()
+      });
+      const rpcEndpoint = this.getRpcEndpoint(options.scope);
+      const rpcRequest = yield this.fetchWithTimeout(
+        rpcEndpoint,
+        body,
+        "POST",
+        this.getHeaders(rpcEndpoint),
+        3e4
+      );
+      const response = yield this.parseResponse(rpcRequest);
+      return response;
     });
   }
-  clearTransportNotificationListener() {
-    var _a3;
-    (_a3 = this.notificationListener) == null ? void 0 : _a3.call(this);
-    this.notificationListener = void 0;
-  }
-  setupTransportNotificationListener() {
-    if (!this.isTransportDefined() || this.notificationListener) {
-      return;
+  getRpcEndpoint(scope) {
+    var _a3, _b, _c;
+    const supportedNetworks = (_c = (_b = (_a3 = this.config) == null ? void 0 : _a3.api) == null ? void 0 : _b.supportedNetworks) != null ? _c : {};
+    const rpcEndpoint = supportedNetworks[scope];
+    if (!rpcEndpoint) {
+      throw new MissingRpcEndpointErr(
+        `No RPC endpoint found for scope ${scope}`
+      );
     }
-    this.notificationListener = this.metamaskConnectMultichain.transport.onNotification(
-      this.notifyCallbacks.bind(this)
-    );
-  }
-  connect() {
-    return __async(this, null, function* () {
-      console.log("\u{1F4DA} connect");
-      yield this.metamaskConnectMultichain.emitSessionChanged();
-    });
+    return rpcEndpoint;
   }
-  disconnect() {
+  fetchWithTimeout(endpoint, body, method, headers, timeout) {
     return __async(this, null, function* () {
-      return Promise.resolve();
-    });
-  }
-  isConnected() {
-    return true;
-  }
-  request(_0) {
-    return __async(this, arguments, function* (params, _options = {}) {
-      const id = getUniqueRequestId();
-      const requestPayload = __spreadValues({
-        id,
-        jsonrpc: "2.0"
-      }, params);
-      switch (requestPayload.method) {
-        case "wallet_createSession":
-          return __privateMethod(this, _MultichainApiClientWrapperTransport_instances, walletCreateSession_fn).call(this, requestPayload);
-        case "wallet_getSession":
-          return __privateMethod(this, _MultichainApiClientWrapperTransport_instances, walletGetSession_fn).call(this, requestPayload);
-        case "wallet_revokeSession":
-          return __privateMethod(this, _MultichainApiClientWrapperTransport_instances, walletRevokeSession_fn).call(this, requestPayload);
-        case "wallet_invokeMethod":
-          return __privateMethod(this, _MultichainApiClientWrapperTransport_instances, walletInvokeMethod_fn).call(this, requestPayload);
-        default:
-          throw new Error(`Unsupported method: ${requestPayload.method}`);
-      }
-      throw new Error(`Unknown method: ${requestPayload.method}`);
-    });
-  }
-  onNotification(callback) {
-    this.setupTransportNotificationListener();
-    __privateGet(this, _notificationCallbacks2).add(callback);
-    return () => {
-      __privateGet(this, _notificationCallbacks2).delete(callback);
-    };
-  }
-};
-_notificationCallbacks2 = new WeakMap();
-_MultichainApiClientWrapperTransport_instances = new WeakSet();
-walletCreateSession_fn = function(request) {
-  return __async(this, null, function* () {
-    const createSessionParams = request.params;
-    const scopes = Object.keys(__spreadValues(__spreadValues({}, createSessionParams.optionalScopes), createSessionParams.requiredScopes));
-    const scopeAccounts = [];
-    scopes.forEach((scope) => {
-      var _a3, _b, _c, _d;
-      const requiredScope = (_a3 = createSessionParams.requiredScopes) == null ? void 0 : _a3[scope];
-      const optionalScope = (_b = createSessionParams.optionalScopes) == null ? void 0 : _b[scope];
-      if (requiredScope) {
-        scopeAccounts.push(...(_c = requiredScope.accounts) != null ? _c : []);
-      }
-      if (optionalScope) {
-        scopeAccounts.push(...(_d = optionalScope.accounts) != null ? _d : []);
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = yield fetch(endpoint, {
+          method,
+          headers,
+          body,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          throw new RPCHttpErr(endpoint, method, response.status);
+        }
+        return response;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof RPCHttpErr) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new RPCReadonlyRequestErr(`Request timeout after ${timeout}ms`);
+        }
+        throw new RPCReadonlyRequestErr(error.message);
       }
     });
-    const accounts = [...new Set(scopeAccounts)];
-    console.log("\u{1F4DA} SDK connect");
-    yield this.metamaskConnectMultichain.connect(
-      scopes,
-      accounts,
-      createSessionParams.sessionProperties
-    );
-    console.log("\u{1F4DA} SDK connected");
-    return this.metamaskConnectMultichain.transport.request({
-      method: "wallet_getSession"
-    });
-  });
-};
-walletGetSession_fn = function(request) {
-  return __async(this, null, function* () {
-    if (!this.isTransportDefined()) {
-      return {
-        jsonrpc: "2.0",
-        id: request.id,
-        result: {
-          sessionScopes: {}
-        }
-      };
-    }
-    return this.metamaskConnectMultichain.transport.request({
-      method: "wallet_getSession"
+  }
+  parseResponse(response) {
+    return __async(this, null, function* () {
+      try {
+        const rpcResponse = yield response.json();
+        return rpcResponse.result;
+      } catch (error) {
+        throw new RPCReadonlyResponseErr(error.message);
+      }
     });
-  });
-};
-walletRevokeSession_fn = function(request) {
-  return __async(this, null, function* () {
-    var _a3;
-    if (!this.isTransportDefined()) {
-      return { jsonrpc: "2.0", id: request.id, result: true };
-    }
-    const revokeSessionParams = request.params;
-    const scopes = (_a3 = revokeSessionParams == null ? void 0 : revokeSessionParams.scopes) != null ? _a3 : [];
-    try {
-      yield this.metamaskConnectMultichain.disconnect(scopes);
-      return { jsonrpc: "2.0", id: request.id, result: true };
-    } catch (_error) {
-      return { jsonrpc: "2.0", id: request.id, result: false };
-    }
-  });
-};
-walletInvokeMethod_fn = function(request) {
-  return __async(this, null, function* () {
-    if (!this.isTransportDefined()) {
-      return { error: providerErrors.unauthorized() };
-    }
-    const result = this.metamaskConnectMultichain.invokeMethod(
-      request.params
-    );
-    return {
-      result
+  }
+  getHeaders(rpcEndpoint) {
+    const defaultHeaders = {
+      Accept: "application/json",
+      "Content-Type": "application/json"
     };
-  });
+    if (rpcEndpoint.includes("infura")) {
+      return __spreadProps(__spreadValues({}, defaultHeaders), {
+        "Metamask-Sdk-Info": this.sdkInfo
+      });
+    }
+    return defaultHeaders;
+  }
 };
 
-// src/multichain/transports/mwp/index.ts
+// src/multichain/rpc/requestRouter.ts
+import { analytics } from "@metamask/analytics";
 init_domain();
 init_utils2();
-import { SessionStore } from "@metamask/mobile-wallet-protocol-core";
-import {
-  TransportTimeoutError
-} from "@metamask/multichain-api-client";
-import { JsonRpcError, providerErrors as providerErrors2, rpcErrors } from "@metamask/rpc-errors";
-
-// src/multichain/transports/constants.ts
-var MULTICHAIN_PROVIDER_STREAM_NAME = "metamask-multichain-provider";
-
-// src/multichain/transports/mwp/index.ts
-var DEFAULT_REQUEST_TIMEOUT2 = 60 * 1e3;
-var CONNECTION_GRACE_PERIOD = 60 * 1e3;
-var DEFAULT_CONNECTION_TIMEOUT = DEFAULT_REQUEST_TIMEOUT2 + CONNECTION_GRACE_PERIOD;
-var DEFAULT_RESUME_TIMEOUT = 10 * 1e3;
-var SESSION_STORE_KEY = "cache_wallet_getSession";
-var ACCOUNTS_STORE_KEY = "cache_eth_accounts";
-var CHAIN_STORE_KEY = "cache_eth_chainId";
-var PENDING_SESSION_REQUEST_KEY = "pending_session_request";
-var CACHED_METHOD_LIST = [
-  "wallet_getSession",
-  "wallet_createSession",
-  "wallet_sessionChanged"
-];
-var CACHED_RESET_METHOD_LIST = [
-  "wallet_revokeSession",
-  "wallet_revokePermissions"
-];
-var logger = createLogger("metamask-sdk:transport");
-var MWPTransport = class {
-  constructor(dappClient, kvstore, options = {
-    requestTimeout: DEFAULT_REQUEST_TIMEOUT2,
-    connectionTimeout: DEFAULT_CONNECTION_TIMEOUT,
-    resumeTimeout: DEFAULT_RESUME_TIMEOUT
-  }) {
-    this.dappClient = dappClient;
-    this.kvstore = kvstore;
-    this.options = options;
-    this.__pendingRequests = /* @__PURE__ */ new Map();
-    this.notificationCallbacks = /* @__PURE__ */ new Set();
-    this.dappClient.on("message", this.handleMessage.bind(this));
-    this.dappClient.on("session_request", (sessionRequest) => {
-      this.currentSessionRequest = sessionRequest;
-      this.kvstore.set(PENDING_SESSION_REQUEST_KEY, JSON.stringify(sessionRequest)).catch((err) => {
-        logger("Failed to store pending session request", err);
-      });
-    });
-    if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
-      this.windowFocusHandler = this.onWindowFocus.bind(this);
-      window.addEventListener("focus", this.windowFocusHandler);
-    }
-  }
-  get pendingRequests() {
-    return this.__pendingRequests;
-  }
-  set pendingRequests(pendingRequests) {
-    this.__pendingRequests = pendingRequests;
-  }
-  get sessionRequest() {
-    return this.currentSessionRequest;
+init_analytics();
+var _RequestRouter_instances, withAnalyticsTracking_fn, trackWalletActionRequested_fn, trackWalletActionSucceeded_fn, trackWalletActionFailed_fn, trackWalletActionRejected_fn;
+var RequestRouter = class {
+  constructor(transport, rpcClient, config, transportType) {
+    this.transport = transport;
+    this.rpcClient = rpcClient;
+    this.config = config;
+    this.transportType = transportType;
+    __privateAdd(this, _RequestRouter_instances);
   }
   /**
-   * Returns the stored pending session request from the dappClient session_request event, if any.
+   * The main entry point for invoking an RPC method.
+   * This method acts as a router, determining the correct handling strategy
+   * for the request and delegating to the appropriate private handler.
    *
-   * @returns The stored SessionRequest, or null if none or invalid.
+   * @param options
    */
-  getStoredPendingSessionRequest() {
+  invokeMethod(options) {
     return __async(this, null, function* () {
-      try {
-        const raw = yield this.kvstore.get(PENDING_SESSION_REQUEST_KEY);
-        if (!raw) {
-          return null;
-        }
-        return JSON.parse(raw);
-      } catch (e) {
-        return null;
+      const { method } = options.request;
+      if (RPC_HANDLED_METHODS.has(method)) {
+        return this.handleWithRpcNode(options);
+      }
+      if (SDK_HANDLED_METHODS.has(method)) {
+        return this.handleWithSdkState(options);
       }
+      return this.handleWithWallet(options);
     });
   }
   /**
-   * Removes the stored pending session request from the KVStore.
-   * This is necessary to ensure that ConnectMultichain is able to correctly
-   * infer the MWP Transport connection attempt status.
+   * Forwards the request directly to the wallet via the transport.
+   *
+   * @param options
    */
-  removeStoredPendingSessionRequest() {
+  handleWithWallet(options) {
     return __async(this, null, function* () {
-      yield this.kvstore.delete(PENDING_SESSION_REQUEST_KEY);
-    });
-  }
-  onWindowFocus() {
-    if (!this.isConnected()) {
-      this.dappClient.reconnect();
-    }
-  }
-  notifyCallbacks(data) {
-    this.notificationCallbacks.forEach((callback) => callback(data));
-  }
-  rejectRequest(id, error = new Error("Request rejected")) {
-    const request = this.pendingRequests.get(id);
-    if (request) {
-      this.pendingRequests.delete(id);
-      clearTimeout(request.timeout);
-      request.reject(error);
-    }
-  }
-  parseWalletError(errorPayload) {
-    const errorData = errorPayload;
-    if (typeof errorData.code === "number" && typeof errorData.message === "string") {
-      const { code, message: message2 } = errorData;
-      if (code >= 1e3 && code <= 4999) {
-        return providerErrors2.custom({ code, message: message2 });
-      }
-      return new JsonRpcError(code, message2);
-    }
-    const message = errorPayload instanceof Error ? errorPayload.message : JSON.stringify(errorPayload);
-    return rpcErrors.internal({ message });
-  }
-  handleMessage(message) {
-    if (typeof message === "object" && message !== null) {
-      if ("data" in message) {
-        const messagePayload = message.data;
-        if ("id" in messagePayload && typeof messagePayload.id === "string") {
-          const request = this.pendingRequests.get(messagePayload.id);
-          if (request) {
-            clearTimeout(request.timeout);
-            if ("error" in messagePayload && messagePayload.error) {
-              this.pendingRequests.delete(messagePayload.id);
-              request.reject(this.parseWalletError(messagePayload.error));
-              return;
+      return __privateMethod(this, _RequestRouter_instances, withAnalyticsTracking_fn).call(this, options, () => __async(this, null, function* () {
+        const request = this.transport.request({
+          method: "wallet_invokeMethod",
+          params: options
+        });
+        const { ui, mobile } = this.config;
+        const { showInstallModal = false } = ui != null ? ui : {};
+        const secure = isSecure();
+        const shouldOpenDeeplink = secure && !showInstallModal;
+        if (shouldOpenDeeplink) {
+          setTimeout(() => __async(this, null, function* () {
+            const session = yield this.transport.getActiveSession();
+            if (!session) {
+              throw new Error("No active session found");
             }
-            const requestWithName = __spreadProps(__spreadValues({}, messagePayload), {
-              method: request.method === "wallet_getSession" || request.method === "wallet_createSession" ? "wallet_sessionChanged" : request.method
-            });
-            const notification = __spreadProps(__spreadValues({}, messagePayload), {
-              method: request.method === "wallet_getSession" || request.method === "wallet_createSession" ? "wallet_sessionChanged" : request.method,
-              params: requestWithName.result
-            });
-            this.notifyCallbacks(notification);
-            request.resolve(requestWithName);
-            this.pendingRequests.delete(messagePayload.id);
-          }
-        } else {
-          if (message.data.method === "metamask_chainChanged") {
-            this.kvstore.set(
-              CHAIN_STORE_KEY,
-              JSON.stringify(
-                message.data.params.chainId
-              )
-            );
-          }
-          if (message.data.method === "metamask_accountsChanged") {
-            this.kvstore.set(
-              ACCOUNTS_STORE_KEY,
-              JSON.stringify(
-                message.data.params
-              )
-            );
-          }
-          if (message.data.method === "wallet_sessionChanged") {
-            const notification = message.data;
-            const response = {
-              result: notification.params
-            };
-            this.kvstore.set(SESSION_STORE_KEY, JSON.stringify(response));
-          }
-          this.notifyCallbacks(message.data);
+            const url = `${METAMASK_DEEPLINK_BASE}/mwp?id=${encodeURIComponent(session.id)}`;
+            if (mobile == null ? void 0 : mobile.preferredOpenLink) {
+              mobile.preferredOpenLink(url, "_self");
+            } else {
+              openDeeplink(this.config, url, METAMASK_CONNECT_BASE_URL);
+            }
+          }), 10);
         }
-      }
-    }
+        const response = yield request;
+        if (response.error) {
+          const { error } = response;
+          throw new RPCInvokeMethodErr(
+            `RPC Request failed with code ${error.code}: ${error.message}`,
+            error.code,
+            error.message
+          );
+        }
+        return response.result;
+      }));
+    });
   }
-  onResumeSuccess(resumeResolve, resumeReject, options) {
+  /**
+   * Routes the request to a configured RPC node.
+   *
+   * @param options
+   */
+  handleWithRpcNode(options) {
     return __async(this, null, function* () {
-      var _a3, _b, _c, _d, _e, _f, _g;
       try {
-        yield this.waitForWalletSessionIfNotCached();
-        const sessionRequest = yield this.request({
-          method: "wallet_getSession"
-        });
-        if (sessionRequest.error) {
-          return resumeReject(new Error(sessionRequest.error.message));
-        }
-        let walletSession = sessionRequest.result;
-        if (walletSession && options) {
-          const currentScopes = Object.keys(
-            (_a3 = walletSession == null ? void 0 : walletSession.sessionScopes) != null ? _a3 : {}
-          );
-          const proposedScopes = (_b = options == null ? void 0 : options.scopes) != null ? _b : [];
-          const proposedCaipAccountIds = (_c = options == null ? void 0 : options.caipAccountIds) != null ? _c : [];
-          const hasSameScopesAndAccounts = isSameScopesAndAccounts(
-            currentScopes,
-            proposedScopes,
-            walletSession,
-            proposedCaipAccountIds
-          );
-          if (options.forceRequest || !hasSameScopesAndAccounts) {
-            const optionalScopes = addValidAccounts(
-              getOptionalScopes((_d = options == null ? void 0 : options.scopes) != null ? _d : []),
-              getValidAccounts((_e = options == null ? void 0 : options.caipAccountIds) != null ? _e : [])
-            );
-            const sessionRequest2 = {
-              optionalScopes
-            };
-            const response = yield this.request({
-              method: "wallet_createSession",
-              params: sessionRequest2
-            });
-            if (response.error) {
-              return resumeReject(new Error(response.error.message));
-            }
-            walletSession = response.result;
-          }
-        } else if (!walletSession) {
-          const optionalScopes = addValidAccounts(
-            getOptionalScopes((_f = options == null ? void 0 : options.scopes) != null ? _f : []),
-            getValidAccounts((_g = options == null ? void 0 : options.caipAccountIds) != null ? _g : [])
-          );
-          const sessionRequest2 = { optionalScopes };
-          const response = yield this.request({
-            method: "wallet_createSession",
-            params: sessionRequest2
-          });
-          if (response.error) {
-            return resumeReject(new Error(response.error.message));
-          }
-          walletSession = response.result;
+        return yield this.rpcClient.request(options);
+      } catch (error) {
+        if (error instanceof MissingRpcEndpointErr) {
+          return this.handleWithWallet(options);
         }
-        yield this.removeStoredPendingSessionRequest();
-        this.notifyCallbacks({
-          method: "wallet_sessionChanged",
-          params: walletSession
-        });
-        return resumeResolve();
-      } catch (err) {
-        return resumeReject(err);
+        throw error;
       }
     });
   }
-  init() {
+  /**
+   * Responds directly from the SDK's session state.
+   *
+   * @param options
+   */
+  handleWithSdkState(options) {
     return __async(this, null, function* () {
+      console.warn(
+        `Method "${options.request.method}" is configured for SDK state handling, but this is not yet implemented. Falling back to wallet passthrough.`
+      );
+      return this.handleWithWallet(options);
+    });
+  }
+};
+_RequestRouter_instances = new WeakSet();
+withAnalyticsTracking_fn = function(options, execute) {
+  return __async(this, null, function* () {
+    var _a3;
+    yield __privateMethod(this, _RequestRouter_instances, trackWalletActionRequested_fn).call(this, options);
+    try {
+      const result = yield execute();
+      yield __privateMethod(this, _RequestRouter_instances, trackWalletActionSucceeded_fn).call(this, options);
+      return result;
+    } catch (error) {
+      const isRejection = isRejectionError(error);
+      if (isRejection) {
+        yield __privateMethod(this, _RequestRouter_instances, trackWalletActionRejected_fn).call(this, options);
+      } else {
+        yield __privateMethod(this, _RequestRouter_instances, trackWalletActionFailed_fn).call(this, options, error);
+      }
+      if (error instanceof RPCInvokeMethodErr) {
+        throw error;
+      }
+      const castError = error;
+      throw new RPCInvokeMethodErr(
+        (_a3 = castError.message) != null ? _a3 : "Unknown error",
+        castError.code
+      );
+    }
+  });
+};
+trackWalletActionRequested_fn = function(options) {
+  return __async(this, null, function* () {
+    const props = yield getWalletActionAnalyticsProperties(
+      this.config,
+      this.config.storage,
+      options,
+      this.transportType
+    );
+    analytics.track("mmconnect_wallet_action_requested", props);
+  });
+};
+trackWalletActionSucceeded_fn = function(options) {
+  return __async(this, null, function* () {
+    const props = yield getWalletActionAnalyticsProperties(
+      this.config,
+      this.config.storage,
+      options,
+      this.transportType
+    );
+    analytics.track("mmconnect_wallet_action_succeeded", props);
+  });
+};
+trackWalletActionFailed_fn = function(options, error) {
+  return __async(this, null, function* () {
+    const props = yield getWalletActionAnalyticsProperties(
+      this.config,
+      this.config.storage,
+      options,
+      this.transportType,
+      extractErrorDiagnostics(error)
+    );
+    analytics.track("mmconnect_wallet_action_failed", props);
+  });
+};
+trackWalletActionRejected_fn = function(options) {
+  return __async(this, null, function* () {
+    const props = yield getWalletActionAnalyticsProperties(
+      this.config,
+      this.config.storage,
+      options,
+      this.transportType
+    );
+    analytics.track("mmconnect_wallet_action_rejected", props);
+  });
+};
+
+// src/multichain/transports/default/index.ts
+init_utils2();
+import {
+  getDefaultTransport
+} from "@metamask/multichain-api-client";
+var DEFAULT_REQUEST_TIMEOUT = 60 * 1e3;
+var _notificationCallbacks, _transport, _defaultRequestOptions, _pendingRequests, _handleResponseListener, _handleNotificationListener, _DefaultTransport_instances, notifyCallbacks_fn, isMetamaskProviderEvent_fn, handleResponse_fn, handleNotification_fn, setupMessageListener_fn, init_fn;
+var DefaultTransport = class {
+  constructor() {
+    __privateAdd(this, _DefaultTransport_instances);
+    __privateAdd(this, _notificationCallbacks, /* @__PURE__ */ new Set());
+    __privateAdd(this, _transport, getDefaultTransport());
+    __privateAdd(this, _defaultRequestOptions, {
+      timeout: DEFAULT_REQUEST_TIMEOUT
     });
+    __privateAdd(this, _pendingRequests, /* @__PURE__ */ new Map());
+    __privateAdd(this, _handleResponseListener);
+    __privateAdd(this, _handleNotificationListener);
   }
-  // TODO: Rename this
   sendEip1193Message(payload, options) {
     return __async(this, null, function* () {
+      __privateMethod(this, _DefaultTransport_instances, setupMessageListener_fn).call(this);
+      const requestId = String(getUniqueRequestId());
       const request = __spreadValues({
         jsonrpc: "2.0",
-        id: String(getUniqueRequestId())
+        id: requestId
       }, payload);
-      const cachedWalletSession = yield this.getCachedResponse(request);
-      if (cachedWalletSession) {
-        this.notifyCallbacks(cachedWalletSession);
-        return cachedWalletSession;
-      }
       return new Promise((resolve, reject) => {
         var _a3;
         const timeout = setTimeout(() => {
-          this.rejectRequest(request.id, new TransportTimeoutError());
-        }, (_a3 = options == null ? void 0 : options.timeout) != null ? _a3 : this.options.requestTimeout);
-        this.pendingRequests.set(request.id, {
-          request,
-          method: request.method,
-          resolve: (response) => __async(this, null, function* () {
-            yield this.storeWalletSession(request, response);
-            return resolve(response);
-          }),
+          __privateGet(this, _pendingRequests).delete(requestId);
+          reject(new Error("Request timeout"));
+        }, (_a3 = options == null ? void 0 : options.timeout) != null ? _a3 : __privateGet(this, _defaultRequestOptions).timeout);
+        __privateGet(this, _pendingRequests).set(requestId, {
+          resolve: (response) => {
+            resolve(response);
+          },
           reject,
           timeout
         });
-        this.dappClient.sendRequest({
-          name: "metamask-provider",
-          data: request
-        }).catch(reject);
+        window.postMessage(
+          {
+            target: "metamask-contentscript",
+            data: {
+              name: "metamask-provider",
+              data: request
+            }
+          },
+          // eslint-disable-next-line no-restricted-globals
+          location.origin
+        );
+      });
+    });
+  }
+  init() {
+    return __async(this, null, function* () {
+      yield __privateMethod(this, _DefaultTransport_instances, init_fn).call(this);
+      let walletSession = { sessionScopes: {} };
+      try {
+        const sessionRequest = yield this.request(
+          { method: "wallet_getSession" },
+          __privateGet(this, _defaultRequestOptions)
+        );
+        walletSession = sessionRequest.result;
+      } catch (e) {
+        console.error(
+          "Failed to get wallet session during DefaultTransport init"
+        );
+      }
+      __privateMethod(this, _DefaultTransport_instances, notifyCallbacks_fn).call(this, {
+        method: "wallet_sessionChanged",
+        params: walletSession
       });
     });
   }
   connect(options) {
     return __async(this, null, function* () {
-      const { dappClient } = this;
-      const session = yield this.getActiveSession();
-      if (session) {
-        logger("active session found", {
-          id: session.id,
-          channel: session.channel,
-          expiresAt: session.expiresAt
-        });
+      var _a3, _b, _c, _d, _e;
+      yield __privateMethod(this, _DefaultTransport_instances, init_fn).call(this);
+      const sessionRequest = yield this.request(
+        { method: "wallet_getSession" },
+        __privateGet(this, _defaultRequestOptions)
+      );
+      if (sessionRequest.error) {
+        throw new Error(sessionRequest.error.message);
       }
-      const storedSessionRequestBeforeConnectionAttempt = yield this.getStoredPendingSessionRequest();
-      let timeout;
-      let initialConnectionMessageHandler;
-      const connectionPromise = new Promise((resolve, reject) => __async(this, null, function* () {
-        let connection;
-        if (session) {
-          connection = new Promise((resumeResolve, resumeReject) => {
-            var _a3;
-            if (this.dappClient.state === "CONNECTED") {
-              this.onResumeSuccess(resumeResolve, resumeReject, options);
-            } else {
-              this.dappClient.once("connected", () => __async(this, null, function* () {
-                this.onResumeSuccess(resumeResolve, resumeReject, options);
-              }));
-              dappClient.resume((_a3 = session == null ? void 0 : session.id) != null ? _a3 : "");
-            }
-          });
-        } else {
-          connection = new Promise(
-            (resolveConnection, rejectConnection) => {
-              var _a3, _b;
-              const optionalScopes = addValidAccounts(
-                getOptionalScopes((_a3 = options == null ? void 0 : options.scopes) != null ? _a3 : []),
-                getValidAccounts((_b = options == null ? void 0 : options.caipAccountIds) != null ? _b : [])
-              );
-              const sessionRequest = {
-                optionalScopes,
-                sessionProperties: options == null ? void 0 : options.sessionProperties
-              };
-              const request = {
-                jsonrpc: "2.0",
-                id: String(getUniqueRequestId()),
-                method: "wallet_createSession",
-                params: sessionRequest
-              };
-              initialConnectionMessageHandler = (message) => __async(this, null, function* () {
-                if (typeof message !== "object" || message === null) {
-                  return;
-                }
-                if (!("data" in message)) {
-                  return;
-                }
-                const messagePayload = message.data;
-                const isMatchingId = messagePayload.id === request.id;
-                const isMatchingMethod = messagePayload.method === "wallet_createSession" || messagePayload.method === "wallet_sessionChanged";
-                if (!isMatchingId && !isMatchingMethod) {
-                  return;
-                }
-                if (messagePayload.error) {
-                  return rejectConnection(
-                    this.parseWalletError(messagePayload.error)
-                  );
-                }
-                yield this.storeWalletSession(
-                  request,
-                  messagePayload
-                );
-                yield this.removeStoredPendingSessionRequest();
-                this.notifyCallbacks(messagePayload);
-                return resolveConnection();
-              });
-              this.dappClient.on("message", initialConnectionMessageHandler);
-              dappClient.connect({
-                mode: "trusted",
-                initialPayload: {
-                  name: MULTICHAIN_PROVIDER_STREAM_NAME,
-                  data: request
-                }
-              }).catch((error) => {
-                if (initialConnectionMessageHandler) {
-                  this.dappClient.off(
-                    "message",
-                    initialConnectionMessageHandler
-                  );
-                }
-                rejectConnection(error);
-              });
-            }
+      let walletSession = sessionRequest.result;
+      const createSessionParams = {
+        optionalScopes: addValidAccounts(
+          getOptionalScopes((_a3 = options == null ? void 0 : options.scopes) != null ? _a3 : []),
+          getValidAccounts((_b = options == null ? void 0 : options.caipAccountIds) != null ? _b : [])
+        ),
+        sessionProperties: options == null ? void 0 : options.sessionProperties
+      };
+      if (walletSession && options && !options.forceRequest) {
+        const currentScopes = Object.keys(
+          (_c = walletSession == null ? void 0 : walletSession.sessionScopes) != null ? _c : {}
+        );
+        const proposedScopes = (_d = options == null ? void 0 : options.scopes) != null ? _d : [];
+        const proposedCaipAccountIds = (_e = options == null ? void 0 : options.caipAccountIds) != null ? _e : [];
+        const hasSameScopesAndAccounts = isSameScopesAndAccounts(
+          currentScopes,
+          proposedScopes,
+          walletSession,
+          proposedCaipAccountIds
+        );
+        if (!hasSameScopesAndAccounts) {
+          const response = yield this.request(
+            { method: "wallet_createSession", params: createSessionParams },
+            __privateGet(this, _defaultRequestOptions)
           );
+          if (response.error) {
+            throw new Error(response.error.message);
+          }
+          walletSession = response.result;
         }
-        timeout = setTimeout(
-          () => {
-            reject(new TransportTimeoutError());
-          },
-          storedSessionRequestBeforeConnectionAttempt ? this.options.resumeTimeout : this.options.connectionTimeout
+      } else if (!walletSession || (options == null ? void 0 : options.forceRequest)) {
+        const response = yield this.request(
+          { method: "wallet_createSession", params: createSessionParams },
+          __privateGet(this, _defaultRequestOptions)
         );
-        connection.then(resolve).catch(reject);
-      }));
-      return connectionPromise.catch((error) => __async(this, null, function* () {
-        yield this.dappClient.disconnect();
-        throw error;
-      })).finally(() => {
-        if (timeout) {
-          clearTimeout(timeout);
-        }
-        if (initialConnectionMessageHandler) {
-          this.dappClient.off("message", initialConnectionMessageHandler);
-          initialConnectionMessageHandler = void 0;
+        if (response.error) {
+          throw new Error(response.error.message);
         }
-        this.removeStoredPendingSessionRequest();
+        walletSession = response.result;
+      }
+      __privateMethod(this, _DefaultTransport_instances, notifyCallbacks_fn).call(this, {
+        method: "wallet_sessionChanged",
+        params: walletSession
       });
     });
   }
-  /**
-   * Disconnects from the Mobile Wallet Protocol
-   *
-   * @param [scopes] - The scopes to revoke. If not provided or empty, all scopes will be revoked.
-   * @returns Nothing
-   */
   disconnect() {
     return __async(this, arguments, function* (scopes = []) {
-      var _a3, _b;
-      const cachedSession = yield this.getCachedResponse({
-        jsonrpc: "2.0",
-        id: "0",
-        method: "wallet_getSession"
-      });
-      const cachedSessionScopes = (_b = (_a3 = cachedSession == null ? void 0 : cachedSession.result) == null ? void 0 : _a3.sessionScopes) != null ? _b : {};
-      const remainingScopes = scopes.length === 0 ? [] : Object.keys(cachedSessionScopes).filter(
-        (scope) => !scopes.includes(scope)
-      );
-      const newSessionScopes = Object.fromEntries(
-        Object.entries(cachedSessionScopes).filter(
-          ([key]) => remainingScopes.includes(key)
-        )
+      yield this.request({ method: "wallet_revokeSession", params: { scopes } });
+    });
+  }
+  isConnected() {
+    return __privateGet(this, _transport).isConnected();
+  }
+  request(_0) {
+    return __async(this, arguments, function* (request, options = __privateGet(this, _defaultRequestOptions)) {
+      return __privateGet(this, _transport).request(request, options);
+    });
+  }
+  onNotification(callback) {
+    __privateGet(this, _transport).onNotification(callback);
+    __privateGet(this, _notificationCallbacks).add(callback);
+    return () => {
+      __privateGet(this, _notificationCallbacks).delete(callback);
+    };
+  }
+  getActiveSession() {
+    return __async(this, null, function* () {
+      throw new Error(
+        "getActiveSession is purposely not implemented for the DefaultTransport"
       );
-      this.request({ method: "wallet_revokeSession", params: { scopes } }).catch(
-        (err) => {
-          console.error("error revoking session", err);
-        }
+    });
+  }
+  getStoredPendingSessionRequest() {
+    return __async(this, null, function* () {
+      throw new Error(
+        "getStoredPendingSessionRequest is purposely not implemented for the DefaultTransport"
       );
-      const remainingScopesIncludeEip155 = remainingScopes.some(
-        (scope) => scope.includes("eip155")
+    });
+  }
+};
+_notificationCallbacks = new WeakMap();
+_transport = new WeakMap();
+_defaultRequestOptions = new WeakMap();
+_pendingRequests = new WeakMap();
+_handleResponseListener = new WeakMap();
+_handleNotificationListener = new WeakMap();
+_DefaultTransport_instances = new WeakSet();
+notifyCallbacks_fn = function(data) {
+  for (const callback of __privateGet(this, _notificationCallbacks)) {
+    try {
+      callback(data);
+    } catch (error) {
+      console.log(
+        "[WindowPostMessageTransport] notifyCallbacks error:",
+        error
       );
-      if (!remainingScopesIncludeEip155) {
-        this.kvstore.delete(ACCOUNTS_STORE_KEY);
-        this.kvstore.delete(CHAIN_STORE_KEY);
-      }
-      if (remainingScopes.length > 0) {
-        this.kvstore.set(
-          SESSION_STORE_KEY,
-          JSON.stringify({
-            result: {
-              sessionScopes: newSessionScopes
-            }
-          })
+    }
+  }
+};
+isMetamaskProviderEvent_fn = function(event) {
+  var _a3, _b;
+  return ((_b = (_a3 = event == null ? void 0 : event.data) == null ? void 0 : _a3.data) == null ? void 0 : _b.name) === "metamask-provider" && // eslint-disable-next-line no-restricted-globals
+  event.origin === location.origin;
+};
+handleResponse_fn = function(event) {
+  var _a3, _b;
+  if (!__privateMethod(this, _DefaultTransport_instances, isMetamaskProviderEvent_fn).call(this, event)) {
+    return;
+  }
+  const responseData = (_b = (_a3 = event == null ? void 0 : event.data) == null ? void 0 : _a3.data) == null ? void 0 : _b.data;
+  if (typeof responseData === "object" && responseData !== null && "method" in responseData) {
+    return;
+  }
+  if (typeof responseData === "object" && responseData !== null && "id" in responseData && ("result" in responseData || "error" in responseData)) {
+    const responseId = String(responseData.id);
+    const pendingRequest = __privateGet(this, _pendingRequests).get(responseId);
+    if (pendingRequest) {
+      clearTimeout(pendingRequest.timeout);
+      __privateGet(this, _pendingRequests).delete(responseId);
+      const response = responseData;
+      if ("error" in response && response.error) {
+        const error = new Error(
+          response.error.message || "Request failed"
         );
-      } else {
-        this.kvstore.delete(SESSION_STORE_KEY);
-        if (typeof window !== "undefined" && typeof window.removeEventListener !== "undefined" && this.windowFocusHandler) {
-          window.removeEventListener("focus", this.windowFocusHandler);
-          this.windowFocusHandler = void 0;
+        if (typeof response.error.code === "number") {
+          error.code = response.error.code;
         }
-        yield this.dappClient.disconnect();
+        pendingRequest.reject(error);
+      } else {
+        pendingRequest.resolve(response);
       }
-      this.notifyCallbacks({
-        method: "wallet_sessionChanged",
-        params: {
-          sessionScopes: newSessionScopes
-        }
-      });
-    });
+    }
   }
-  /**
-   * Checks if the transport is connected
-   *
-   * @returns True if transport is connected, false otherwise
-   */
-  isConnected() {
-    return this.dappClient.state === "CONNECTED";
+};
+handleNotification_fn = function(event) {
+  var _a3, _b;
+  if (!__privateMethod(this, _DefaultTransport_instances, isMetamaskProviderEvent_fn).call(this, event)) {
+    return;
   }
-  /**
-   * Attempts to re-establish a connection via DappClient
-   *
-   * @returns Nothing
-   */
-  // TODO: We should re-evaluate adding this to the WebSocketTransport layer from `@metamask/mobile-wallet-protocol-core`
-  // ticket: https://consensyssoftware.atlassian.net/browse/WAPI-862
-  attemptResumeSession() {
-    return __async(this, null, function* () {
-      try {
-        yield this.dappClient.reconnect();
-        yield new Promise((resolve, reject) => {
-          const timeout = setTimeout(() => {
-            reject(new Error("Resume timeout"));
-          }, 2e3);
-          if (this.isConnected()) {
-            clearTimeout(timeout);
-            resolve();
-          } else {
-            this.dappClient.once("connected", () => {
-              clearTimeout(timeout);
-              resolve();
-            });
-          }
-        });
-      } catch (error) {
-        return Promise.reject(
-          new Error(`Failed to resume session: ${error.message}`)
-        );
-      }
+  const responseData = (_b = (_a3 = event == null ? void 0 : event.data) == null ? void 0 : _a3.data) == null ? void 0 : _b.data;
+  if (typeof responseData === "object" && responseData !== null && "method" in responseData) {
+    __privateMethod(this, _DefaultTransport_instances, notifyCallbacks_fn).call(this, responseData);
+  }
+};
+setupMessageListener_fn = function() {
+  if (__privateGet(this, _handleResponseListener)) {
+    return;
+  }
+  __privateSet(this, _handleResponseListener, __privateMethod(this, _DefaultTransport_instances, handleResponse_fn).bind(this));
+  __privateSet(this, _handleNotificationListener, __privateMethod(this, _DefaultTransport_instances, handleNotification_fn).bind(this));
+  window.addEventListener("message", __privateGet(this, _handleResponseListener));
+  window.addEventListener("message", __privateGet(this, _handleNotificationListener));
+};
+init_fn = function() {
+  return __async(this, null, function* () {
+    __privateMethod(this, _DefaultTransport_instances, setupMessageListener_fn).call(this);
+    if (!__privateGet(this, _transport).isConnected()) {
+      yield __privateGet(this, _transport).connect();
+    }
+  });
+};
+
+// src/multichain/transports/multichainApiClientWrapper/index.ts
+init_utils2();
+import { providerErrors } from "@metamask/rpc-errors";
+var _notificationCallbacks2, _MultichainApiClientWrapperTransport_instances, walletCreateSession_fn, walletGetSession_fn, walletRevokeSession_fn, walletInvokeMethod_fn;
+var MultichainApiClientWrapperTransport = class {
+  constructor(metamaskConnectMultichain) {
+    this.metamaskConnectMultichain = metamaskConnectMultichain;
+    __privateAdd(this, _MultichainApiClientWrapperTransport_instances);
+    __privateAdd(this, _notificationCallbacks2, /* @__PURE__ */ new Set());
+  }
+  isTransportDefined() {
+    try {
+      return Boolean(this.metamaskConnectMultichain.transport);
+    } catch (_error) {
+      return false;
+    }
+  }
+  isTransportConnected() {
+    return this.isTransportDefined() && this.metamaskConnectMultichain.transport.isConnected();
+  }
+  clearNotificationCallbacks() {
+    __privateGet(this, _notificationCallbacks2).clear();
+  }
+  notifyCallbacks(data) {
+    __privateGet(this, _notificationCallbacks2).forEach((callback) => {
+      callback(data);
     });
   }
-  getCachedResponse(request) {
+  clearTransportNotificationListener() {
+    var _a3;
+    (_a3 = this.notificationListener) == null ? void 0 : _a3.call(this);
+    this.notificationListener = void 0;
+  }
+  setupTransportNotificationListener() {
+    if (!this.isTransportDefined() || this.notificationListener) {
+      return;
+    }
+    this.notificationListener = this.metamaskConnectMultichain.transport.onNotification(
+      this.notifyCallbacks.bind(this)
+    );
+  }
+  // Purposely noop, resolves successfully. Actual connection is handled by the underlying client/transport.
+  connect() {
     return __async(this, null, function* () {
-      var _a3;
-      if (request.method === "wallet_getSession") {
-        const walletGetSession = yield this.kvstore.get(SESSION_STORE_KEY);
-        if (walletGetSession) {
-          const walletSession = JSON.parse(walletGetSession);
-          return {
-            id: request.id,
-            jsonrpc: "2.0",
-            result: (_a3 = walletSession.params) != null ? _a3 : walletSession.result,
-            // "what?... why walletSession.params?.."
-            method: request.method
-          };
-        }
-      } else if (request.method === "eth_accounts") {
-        const ethAccounts = yield this.kvstore.get(ACCOUNTS_STORE_KEY);
-        if (ethAccounts) {
-          return {
-            id: request.id,
-            jsonrpc: "2.0",
-            result: JSON.parse(ethAccounts),
-            method: request.method
-          };
-        }
-      } else if (request.method === "eth_chainId") {
-        const ethChainId = yield this.kvstore.get(CHAIN_STORE_KEY);
-        if (ethChainId) {
-          return {
-            id: request.id,
-            jsonrpc: "2.0",
-            result: JSON.parse(ethChainId),
-            method: request.method
-          };
-        }
-      }
+      return Promise.resolve();
     });
   }
-  storeWalletSession(request, response) {
+  // Purposely noop, resolves successfully. Actual connection is handled by the underlying client/transport.
+  disconnect() {
     return __async(this, null, function* () {
-      if (response.error) {
-        return;
-      }
-      if (CACHED_METHOD_LIST.includes(request.method)) {
-        yield this.kvstore.set(SESSION_STORE_KEY, JSON.stringify(response));
-      } else if (request.method === "eth_accounts") {
-        yield this.kvstore.set(
-          ACCOUNTS_STORE_KEY,
-          JSON.stringify(response.result)
-        );
-      } else if (request.method === "eth_chainId") {
-        yield this.kvstore.set(CHAIN_STORE_KEY, JSON.stringify(response.result));
-      } else if (CACHED_RESET_METHOD_LIST.includes(request.method)) {
-        yield this.kvstore.delete(SESSION_STORE_KEY);
-        yield this.kvstore.delete(ACCOUNTS_STORE_KEY);
-        yield this.kvstore.delete(CHAIN_STORE_KEY);
-      }
+      return Promise.resolve();
     });
   }
-  request(payload, options) {
-    return __async(this, null, function* () {
-      const request = __spreadValues({
-        jsonrpc: "2.0",
-        id: String(getUniqueRequestId())
-      }, payload);
-      const cachedWalletSession = yield this.getCachedResponse(request);
-      if (cachedWalletSession) {
-        this.notifyCallbacks(cachedWalletSession);
-        return cachedWalletSession;
-      }
-      if (!this.isConnected()) {
-        yield this.attemptResumeSession();
+  // Purposely hardcoded to true. Actual connection is handled by the underlying client/transport.
+  isConnected() {
+    return true;
+  }
+  request(_0) {
+    return __async(this, arguments, function* (params, _options = {}) {
+      const id = getUniqueRequestId();
+      const requestPayload = __spreadValues({
+        id,
+        jsonrpc: "2.0"
+      }, params);
+      switch (requestPayload.method) {
+        case "wallet_createSession":
+          return __privateMethod(this, _MultichainApiClientWrapperTransport_instances, walletCreateSession_fn).call(this, requestPayload);
+        case "wallet_getSession":
+          return __privateMethod(this, _MultichainApiClientWrapperTransport_instances, walletGetSession_fn).call(this, requestPayload);
+        case "wallet_revokeSession":
+          return __privateMethod(this, _MultichainApiClientWrapperTransport_instances, walletRevokeSession_fn).call(this, requestPayload);
+        case "wallet_invokeMethod":
+          return __privateMethod(this, _MultichainApiClientWrapperTransport_instances, walletInvokeMethod_fn).call(this, requestPayload);
+        default:
+          throw new Error(`Unsupported method: ${requestPayload.method}`);
       }
-      return new Promise((resolve, reject) => {
-        var _a3;
-        const timeout = setTimeout(() => {
-          this.rejectRequest(request.id, new TransportTimeoutError());
-        }, (_a3 = options == null ? void 0 : options.timeout) != null ? _a3 : this.options.requestTimeout);
-        this.pendingRequests.set(request.id, {
-          request,
-          method: request.method,
-          resolve: (response) => __async(this, null, function* () {
-            yield this.storeWalletSession(request, response);
-            return resolve(response);
-          }),
-          reject,
-          timeout
-        });
-        this.dappClient.sendRequest({
-          name: MULTICHAIN_PROVIDER_STREAM_NAME,
-          data: request
-        }).catch(reject);
-      });
     });
   }
   onNotification(callback) {
-    this.notificationCallbacks.add(callback);
+    this.setupTransportNotificationListener();
+    __privateGet(this, _notificationCallbacks2).add(callback);
     return () => {
-      this.notificationCallbacks.delete(callback);
+      __privateGet(this, _notificationCallbacks2).delete(callback);
     };
   }
-  getActiveSession() {
-    return __async(this, null, function* () {
-      const { kvstore } = this;
-      const sessionStore = yield SessionStore.create(kvstore);
-      try {
-        const [activeSession] = yield sessionStore.list();
-        return activeSession;
-      } catch (error) {
-        logger("error getting active session", error);
-        return void 0;
+};
+_notificationCallbacks2 = new WeakMap();
+_MultichainApiClientWrapperTransport_instances = new WeakSet();
+walletCreateSession_fn = function(request) {
+  return __async(this, null, function* () {
+    const createSessionParams = request.params;
+    const scopes = Object.keys(__spreadValues(__spreadValues({}, createSessionParams.optionalScopes), createSessionParams.requiredScopes));
+    const scopeAccounts = [];
+    scopes.forEach((scope) => {
+      var _a3, _b, _c, _d;
+      const requiredScope = (_a3 = createSessionParams.requiredScopes) == null ? void 0 : _a3[scope];
+      const optionalScope = (_b = createSessionParams.optionalScopes) == null ? void 0 : _b[scope];
+      if (requiredScope) {
+        scopeAccounts.push(...(_c = requiredScope.accounts) != null ? _c : []);
       }
-    });
-  }
-  // This method checks if an existing CAIP session response is cached or waits for one
-  // to be received from the wallet if not cached. This is necessary because there is an edge
-  // case during the initial connection flow where after the user has accepted the permission approval
-  // and returned back to the dapp from the wallet, the dapp page may have gotten unloaded and refreshed.
-  // When it is unloaded and refreshed, it will try to resume the session by making a request for wallet_getSession
-  // which should resolve from cache, but because a race condition makes it possible for the response from the wallet
-  // for the initial wallet_createSession connection request to not have been handled and cached yet. This results
-  // in the wallet_getSession request never resolving unless we wait for it explicitly as done in this method.
-  waitForWalletSessionIfNotCached() {
-    return __async(this, null, function* () {
-      const cachedWalletGetSessionResponse = yield this.kvstore.get(SESSION_STORE_KEY);
-      if (cachedWalletGetSessionResponse) {
-        return;
+      if (optionalScope) {
+        scopeAccounts.push(...(_d = optionalScope.accounts) != null ? _d : []);
       }
-      let unsubscribe;
-      const responsePromise = new Promise((resolve) => {
-        unsubscribe = this.onNotification((message) => {
-          if (typeof message === "object" && message !== null) {
-            if ("data" in message) {
-              const messagePayload = message.data;
-              if (messagePayload.method === "wallet_getSession" || messagePayload.method === "wallet_sessionChanged") {
-                unsubscribe();
-                resolve();
-              }
-            }
-          }
-        });
-      });
-      const timeoutPromise = new Promise((_resolve, reject) => {
-        setTimeout(() => {
-          unsubscribe();
-          this.removeStoredPendingSessionRequest();
-          reject(new TransportTimeoutError());
-        }, this.options.resumeTimeout);
-      });
-      return Promise.race([responsePromise, timeoutPromise]);
     });
-  }
+    const accounts = [...new Set(scopeAccounts)];
+    yield this.metamaskConnectMultichain.connect(
+      scopes,
+      accounts,
+      createSessionParams.sessionProperties
+    );
+    return this.metamaskConnectMultichain.transport.request({
+      method: "wallet_getSession"
+    });
+  });
 };
-
-// src/multichain/transports/mwp/KeyManager.ts
-import { decrypt, encrypt, PrivateKey, PublicKey } from "eciesjs";
-var KeyManager = class {
-  generateKeyPair() {
-    const privateKey = new PrivateKey();
+walletGetSession_fn = function(request) {
+  return __async(this, null, function* () {
+    if (!this.isTransportConnected()) {
+      return {
+        jsonrpc: "2.0",
+        id: request.id,
+        result: {
+          sessionScopes: {}
+        }
+      };
+    }
+    return this.metamaskConnectMultichain.transport.request({
+      method: "wallet_getSession"
+    });
+  });
+};
+walletRevokeSession_fn = function(request) {
+  return __async(this, null, function* () {
+    var _a3;
+    const revokeSessionParams = request.params;
+    const scopes = (_a3 = revokeSessionParams == null ? void 0 : revokeSessionParams.scopes) != null ? _a3 : [];
+    try {
+      yield this.metamaskConnectMultichain.disconnect(scopes);
+      return { jsonrpc: "2.0", id: request.id, result: true };
+    } catch (_error) {
+      return { jsonrpc: "2.0", id: request.id, result: false };
+    }
+  });
+};
+walletInvokeMethod_fn = function(request) {
+  return __async(this, null, function* () {
+    if (!this.isTransportConnected()) {
+      return { error: providerErrors.unauthorized() };
+    }
+    const result = this.metamaskConnectMultichain.invokeMethod(
+      request.params
+    );
     return {
-      privateKey: new Uint8Array(privateKey.secret),
-      publicKey: privateKey.publicKey.toBytes(true)
+      result
     };
-  }
-  encrypt(plaintext, theirPublicKey) {
-    return __async(this, null, function* () {
-      const plaintextBuffer = Buffer.from(plaintext, "utf8");
-      const encryptedBuffer = encrypt(theirPublicKey, plaintextBuffer);
-      return encryptedBuffer.toString("base64");
-    });
-  }
-  decrypt(encryptedB64, myPrivateKey) {
-    return __async(this, null, function* () {
-      const encryptedBuffer = Buffer.from(encryptedB64, "base64");
-      const decryptedBuffer = yield decrypt(myPrivateKey, encryptedBuffer);
-      return Buffer.from(decryptedBuffer).toString("utf8");
-    });
-  }
-  validatePeerKey(key) {
-    PublicKey.fromHex(Buffer.from(key).toString("hex"));
-  }
+  });
 };
-var keymanager = new KeyManager();
 
 // src/multichain/index.ts
 init_utils2();
 var logger2 = createLogger("metamask-sdk:core");
 var SINGLETON_KEY = "__METAMASK_CONNECT_MULTICHAIN_SINGLETON__";
-var _a2, _provider, _providerTransportWrapper, _transport2, _dappClient, _beforeUnloadListener, _listener, _anonId, _sdkInfo, _MetaMaskConnectMultichain_instances, setupAnalytics_fn, onTransportNotification_fn, getStoredTransport_fn, setupTransport_fn, buildConnectionMetadata_fn, init_fn2, createDappClient_fn, setupMWP_fn, onBeforeUnload_fn, createBeforeUnloadListener_fn, renderInstallModalAsync_fn, showInstallModal_fn, headlessConnect_fn, setupDefaultTransport_fn, deeplinkConnect_fn, handleConnection_fn, getCaipSession_fn, openConnectDeeplinkIfNeeded_fn;
+var _a2, _provider, _providerTransportWrapper, _transport2, _dappClient, _beforeUnloadListener, _transportType, _listener, _anonId, _sdkInfo, _MetaMaskConnectMultichain_instances, setupAnalytics_fn, onTransportNotification_fn, getStoredTransport_fn, setupTransport_fn, buildConnectionMetadata_fn, init_fn2, createDappClient_fn, setupMWP_fn, onBeforeUnload_fn, createBeforeUnloadListener_fn, renderInstallModalAsync_fn, showInstallModal_fn, headlessConnect_fn, setupDefaultTransport_fn, deeplinkConnect_fn, handleConnection_fn, getCaipSession_fn, openConnectDeeplinkIfNeeded_fn;
 var _MetaMaskConnectMultichain = class _MetaMaskConnectMultichain extends MultichainCore {
   constructor(options) {
     var _a3, _b, _c, _d, _e, _f;
@@ -2758,7 +2901,7 @@ var _MetaMaskConnectMultichain = class _MetaMaskConnectMultichain extends Multic
       versions: __spreadValues({
         // typeof guard needed: Metro (React Native) bundles TS source directly,
         // bypassing the tsup build that substitutes __PACKAGE_VERSION__.
-        "connect-multichain": false ? "unknown" : "0.12.1"
+        "connect-multichain": false ? "unknown" : "0.14.0"
       }, (_f = options.versions) != null ? _f : {})
     });
     super(allOptions);
@@ -2768,6 +2911,7 @@ var _MetaMaskConnectMultichain = class _MetaMaskConnectMultichain extends Multic
     __privateAdd(this, _transport2);
     __privateAdd(this, _dappClient);
     __privateAdd(this, _beforeUnloadListener);
+    __privateAdd(this, _transportType);
     this._status = "pending";
     __privateAdd(this, _listener);
     __privateAdd(this, _anonId);
@@ -2804,12 +2948,13 @@ var _MetaMaskConnectMultichain = class _MetaMaskConnectMultichain extends Multic
     }
     return __privateGet(this, _dappClient);
   }
+  get transportType() {
+    var _a3;
+    return (_a3 = __privateGet(this, _transportType)) != null ? _a3 : "unknown" /* UNKNOWN */;
+  }
   get storage() {
     return this.options.storage;
   }
-  get transportType() {
-    return __privateGet(this, _transport2) instanceof MWPTransport ? "mwp" /* MWP */ : "browser" /* Browser */;
-  }
   // Creates a singleton instance of MetaMaskConnectMultichain.
   // If the singleton already exists, it merges the incoming options with the
   // existing singleton options for the following keys: `api.supportedNetworks`,
@@ -2863,7 +3008,7 @@ var _MetaMaskConnectMultichain = class _MetaMaskConnectMultichain extends Multic
   connect(scopes, caipAccountIds, sessionProperties, forceRequest) {
     return __async(this, null, function* () {
       var _a3;
-      if (this.status === "connecting" && this.transportType === "mwp" /* MWP */) {
+      if (this.status === "connecting" && __privateGet(this, _transportType) === "mwp" /* MWP */) {
         yield __privateMethod(this, _MetaMaskConnectMultichain_instances, openConnectDeeplinkIfNeeded_fn).call(this);
         throw new Error(
           "Existing connection is pending. Please check your MetaMask Mobile app to continue."
@@ -2912,7 +3057,7 @@ var _MetaMaskConnectMultichain = class _MetaMaskConnectMultichain extends Multic
           sessionProperties: nonEmptySessionProperties,
           forceRequest
         }).then(() => __async(this, null, function* () {
-          if (__privateGet(this, _transport2) instanceof MWPTransport) {
+          if (__privateGet(this, _transportType) === "mwp" /* MWP */) {
             return this.storage.setTransport("mwp" /* MWP */);
           }
           return this.storage.setTransport("browser" /* Browser */);
@@ -2959,12 +3104,13 @@ var _MetaMaskConnectMultichain = class _MetaMaskConnectMultichain extends Multic
       yield (_a3 = __privateGet(this, _transport2)) == null ? void 0 : _a3.disconnect(scopes);
       if (remainingScopes.length === 0) {
         yield this.storage.removeTransport();
-        if (this.transportType !== "browser" /* Browser */) {
+        if (__privateGet(this, _transportType) !== "browser" /* Browser */) {
           yield (_b = __privateGet(this, _listener)) == null ? void 0 : _b.call(this);
           (_c = __privateGet(this, _beforeUnloadListener)) == null ? void 0 : _c.call(this);
           __privateSet(this, _listener, void 0);
           __privateSet(this, _beforeUnloadListener, void 0);
           __privateSet(this, _transport2, void 0);
+          __privateSet(this, _transportType, void 0);
           __privateGet(this, _providerTransportWrapper).clearTransportNotificationListener();
           __privateSet(this, _dappClient, void 0);
         }
@@ -2974,13 +3120,14 @@ var _MetaMaskConnectMultichain = class _MetaMaskConnectMultichain extends Multic
   }
   invokeMethod(request) {
     return __async(this, null, function* () {
+      var _a3;
       const { transport, options } = this;
       const rpcClient = new RpcClient(options, __privateGet(this, _sdkInfo));
       const requestRouter = new RequestRouter(
         transport,
         rpcClient,
         options,
-        this.transportType
+        (_a3 = __privateGet(this, _transportType)) != null ? _a3 : "unknown" /* UNKNOWN */
       );
       return requestRouter.invokeMethod(request);
     });
@@ -3029,6 +3176,7 @@ _providerTransportWrapper = new WeakMap();
 _transport2 = new WeakMap();
 _dappClient = new WeakMap();
 _beforeUnloadListener = new WeakMap();
+_transportType = new WeakMap();
 _listener = new WeakMap();
 _anonId = new WeakMap();
 _sdkInfo = new WeakMap();
@@ -3086,6 +3234,7 @@ getStoredTransport_fn = function() {
         if (hasExtensionInstalled) {
           const apiTransport = new DefaultTransport();
           __privateSet(this, _transport2, apiTransport);
+          __privateSet(this, _transportType, "browser" /* Browser */);
           __privateGet(this, _providerTransportWrapper).setupTransportNotificationListener();
           __privateSet(this, _listener, apiTransport.onNotification(
             __privateMethod(this, _MetaMaskConnectMultichain_instances, onTransportNotification_fn).bind(this)
@@ -3095,9 +3244,11 @@ getStoredTransport_fn = function() {
       } else if (transportType === "mwp" /* MWP */) {
         const { adapter: kvstore } = this.options.storage;
         const dappClient = yield __privateMethod(this, _MetaMaskConnectMultichain_instances, createDappClient_fn).call(this);
-        const apiTransport = new MWPTransport(dappClient, kvstore);
+        const { MWPTransport: MWPTransport2 } = yield Promise.resolve().then(() => (init_mwp(), mwp_exports));
+        const apiTransport = new MWPTransport2(dappClient, kvstore);
         __privateSet(this, _dappClient, dappClient);
         __privateSet(this, _transport2, apiTransport);
+        __privateSet(this, _transportType, "mwp" /* MWP */);
         __privateGet(this, _providerTransportWrapper).setupTransportNotificationListener();
         __privateSet(this, _listener, apiTransport.onNotification(
           __privateMethod(this, _MetaMaskConnectMultichain_instances, onTransportNotification_fn).bind(this)
@@ -3119,7 +3270,7 @@ setupTransport_fn = function() {
         yield this.transport.connect();
       }
       this.status = "connected";
-      if (this.transport instanceof MWPTransport) {
+      if (__privateGet(this, _transportType) === "mwp" /* MWP */) {
         yield this.storage.setTransport("mwp" /* MWP */);
       } else {
         yield this.storage.setTransport("browser" /* Browser */);
@@ -3163,31 +3314,43 @@ init_fn2 = function() {
 };
 createDappClient_fn = function() {
   return __async(this, null, function* () {
+    const [mwpCore, { DappClient: DappClientClass }, { createKeyManager: createKeyManager2 }] = yield Promise.all([
+      import("@metamask/mobile-wallet-protocol-core"),
+      import("@metamask/mobile-wallet-protocol-dapp-client"),
+      Promise.resolve().then(() => (init_KeyManager(), KeyManager_exports))
+    ]);
+    const keymanager = yield createKeyManager2();
     const { adapter: kvstore } = this.options.storage;
-    const sessionstore = yield SessionStore2.create(kvstore);
+    const sessionstore = yield mwpCore.SessionStore.create(kvstore);
     const websocket = (
       // eslint-disable-next-line no-negated-condition
       typeof window !== "undefined" ? WebSocket : (yield import("ws")).WebSocket
     );
-    const transport = yield WebSocketTransport.create({
+    const transport = yield mwpCore.WebSocketTransport.create({
       url: MWP_RELAY_URL,
       kvstore,
       websocket
     });
-    const dappClient = new DappClient({ transport, sessionstore, keymanager });
+    const dappClient = new DappClientClass({
+      transport,
+      sessionstore,
+      keymanager
+    });
     return dappClient;
   });
 };
 setupMWP_fn = function() {
   return __async(this, null, function* () {
-    if (__privateGet(this, _transport2) instanceof MWPTransport) {
+    if (__privateGet(this, _transportType) === "mwp" /* MWP */) {
       return;
     }
     const { adapter: kvstore } = this.options.storage;
     const dappClient = yield __privateMethod(this, _MetaMaskConnectMultichain_instances, createDappClient_fn).call(this);
     __privateSet(this, _dappClient, dappClient);
-    const apiTransport = new MWPTransport(dappClient, kvstore);
+    const { MWPTransport: MWPTransport2 } = yield Promise.resolve().then(() => (init_mwp(), mwp_exports));
+    const apiTransport = new MWPTransport2(dappClient, kvstore);
     __privateSet(this, _transport2, apiTransport);
+    __privateSet(this, _transportType, "mwp" /* MWP */);
     __privateGet(this, _providerTransportWrapper).setupTransportNotificationListener();
     __privateSet(this, _listener, this.transport.onNotification(
       __privateMethod(this, _MetaMaskConnectMultichain_instances, onTransportNotification_fn).bind(this)
@@ -3246,6 +3409,7 @@ renderInstallModalAsync_fn = function(desktopPreferred, scopes, caipAccountIds,
                 this.status = "connected";
                 yield this.storage.setTransport("mwp" /* MWP */);
               } catch (error) {
+                const { ProtocolError, ErrorCode } = yield import("@metamask/mobile-wallet-protocol-core");
                 if (error instanceof ProtocolError) {
                   if (error.code !== ErrorCode.REQUEST_EXPIRED) {
                     this.status = "disconnected";
@@ -3315,6 +3479,7 @@ headlessConnect_fn = function(scopes, caipAccountIds, sessionProperties) {
         yield this.storage.setTransport("mwp" /* MWP */);
         resolve();
       })).catch((error) => __async(this, null, function* () {
+        const { ProtocolError } = yield import("@metamask/mobile-wallet-protocol-core");
         if (error instanceof ProtocolError) {
           this.status = "disconnected";
           yield this.storage.removeTransport();
@@ -3330,7 +3495,7 @@ headlessConnect_fn = function(scopes, caipAccountIds, sessionProperties) {
 };
 setupDefaultTransport_fn = function() {
   return __async(this, arguments, function* (options = { persist: true }) {
-    if (__privateGet(this, _transport2) instanceof DefaultTransport) {
+    if (__privateGet(this, _transportType) === "browser" /* Browser */) {
       return __privateGet(this, _transport2);
     }
     if (options == null ? void 0 : options.persist) {
@@ -3341,6 +3506,7 @@ setupDefaultTransport_fn = function() {
       __privateMethod(this, _MetaMaskConnectMultichain_instances, onTransportNotification_fn).bind(this)
     ));
     __privateSet(this, _transport2, transport);
+    __privateSet(this, _transportType, "browser" /* Browser */);
     __privateGet(this, _providerTransportWrapper).setupTransportNotificationListener();
     return transport;
   });
@@ -3437,9 +3603,9 @@ handleConnection_fn = function(promise, scopes, transportType) {
             transport_type: transportType
           }));
         } else {
-          analytics2.track("mmconnect_connection_failed", __spreadProps(__spreadValues({}, baseProps), {
+          analytics2.track("mmconnect_connection_failed", __spreadValues(__spreadProps(__spreadValues({}, baseProps), {
             transport_type: transportType
-          }));
+          }), extractErrorDiagnostics(error)));
         }
       } catch (e) {
         logger2("Error tracking connection failed/rejected event", error);
@@ -3884,6 +4050,7 @@ export {
   StoreAdapter,
   StoreClient,
   TransportType,
+  classifyFailureReason,
   createLogger,
   createMultichainClient,
   enableDebug,