@metamask/connect-multichain 0.12.1 → 0.14.0

package/dist/react-native/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,6 +1136,719 @@ var init_utils2 = __esm({
   }
 });
 
+// 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/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_domain();
+    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 pendingRequests() {
+        return this.__pendingRequests;
+      }
+      set pendingRequests(pendingRequests) {
+        this.__pendingRequests = pendingRequests;
+      }
+      get sessionRequest() {
+        return this.currentSessionRequest;
+      }
+      /**
+       * 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;
+          }
+        });
+      }
+      /**
+       * 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();
+        }
+      }
+      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;
+                }
+                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 : {}
+              );
+              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);
+          }
+        });
+      }
+      init() {
+        return __async(this, null, function* () {
+        });
+      }
+      // 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);
+          });
+        });
+      }
+      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();
+          });
+        });
+      }
+      /**
+       * 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
+            }
+          });
+        });
+      }
+      /**
+       * Checks if the transport is connected
+       *
+       * @returns True if transport is connected, false otherwise
+       */
+      isConnected() {
+        return this.dappClient.state === "CONNECTED";
+      }
+      /**
+       * 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}`)
+            );
+          }
+        });
+      }
+      getCachedResponse(request) {
+        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
+              };
+            }
+          }
+        });
+      }
+      storeWalletSession(request, response) {
+        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);
+          }
+        });
+      }
+      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) => {
+            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);
+        return () => {
+          this.notificationCallbacks.delete(callback);
+        };
+      }
+      getActiveSession() {
+        return __async(this, null, function* () {
+          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]);
+        });
+      }
+    };
+  }
+});
+
+// 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 init_KeyManager = __esm({
+  "src/multichain/transports/mwp/KeyManager.ts"() {
+    "use strict";
+  }
+});
+
 // src/ui/modals/base/utils.ts
 function formatRemainingTime(milliseconds) {
   if (milliseconds <= 0) {
@@ -1255,13 +2080,6 @@ 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";
@@ -1504,7 +2322,7 @@ withAnalyticsTracking_fn = function(options, execute) {
       if (isRejection) {
         yield __privateMethod(this, _RequestRouter_instances, trackWalletActionRejected_fn).call(this, options);
       } else {
-        yield __privateMethod(this, _RequestRouter_instances, trackWalletActionFailed_fn).call(this, options);
+        yield __privateMethod(this, _RequestRouter_instances, trackWalletActionFailed_fn).call(this, options, error);
       }
       if (error instanceof RPCInvokeMethodErr) {
         throw error;
@@ -1539,13 +2357,14 @@ trackWalletActionSucceeded_fn = function(options) {
     analytics.track("mmconnect_wallet_action_succeeded", props);
   });
 };
-trackWalletActionFailed_fn = function(options) {
+trackWalletActionFailed_fn = function(options, error) {
   return __async(this, null, function* () {
     const props = yield getWalletActionAnalyticsProperties(
       this.config,
       this.config.storage,
       options,
-      this.transportType
+      this.transportType,
+      extractErrorDiagnostics(error)
     );
     analytics.track("mmconnect_wallet_action_failed", props);
   });
@@ -1828,6 +2647,9 @@ var MultichainApiClientWrapperTransport = class {
       return false;
     }
   }
+  isTransportConnected() {
+    return this.isTransportDefined() && this.metamaskConnectMultichain.transport.isConnected();
+  }
   clearNotificationCallbacks() {
     __privateGet(this, _notificationCallbacks2).clear();
   }
@@ -1849,17 +2671,19 @@ var MultichainApiClientWrapperTransport = class {
       this.notifyCallbacks.bind(this)
     );
   }
+  // Purposely noop, resolves successfully. Actual connection is handled by the underlying client/transport.
   connect() {
     return __async(this, null, function* () {
-      console.log("\u{1F4DA} connect");
-      yield this.metamaskConnectMultichain.emitSessionChanged();
+      return Promise.resolve();
     });
   }
+  // Purposely noop, resolves successfully. Actual connection is handled by the underlying client/transport.
   disconnect() {
     return __async(this, null, function* () {
       return Promise.resolve();
     });
   }
+  // Purposely hardcoded to true. Actual connection is handled by the underlying client/transport.
   isConnected() {
     return true;
   }
@@ -1882,7 +2706,6 @@ var MultichainApiClientWrapperTransport = class {
         default:
           throw new Error(`Unsupported method: ${requestPayload.method}`);
       }
-      throw new Error(`Unknown method: ${requestPayload.method}`);
     });
   }
   onNotification(callback) {
@@ -1912,13 +2735,11 @@ walletCreateSession_fn = function(request) {
       }
     });
     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"
     });
@@ -1926,7 +2747,7 @@ walletCreateSession_fn = function(request) {
 };
 walletGetSession_fn = function(request) {
   return __async(this, null, function* () {
-    if (!this.isTransportDefined()) {
+    if (!this.isTransportConnected()) {
       return {
         jsonrpc: "2.0",
         id: request.id,
@@ -1943,9 +2764,6 @@ walletGetSession_fn = function(request) {
 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 {
@@ -1958,7 +2776,7 @@ walletRevokeSession_fn = function(request) {
 };
 walletInvokeMethod_fn = function(request) {
   return __async(this, null, function* () {
-    if (!this.isTransportDefined()) {
+    if (!this.isTransportConnected()) {
       return { error: providerErrors.unauthorized() };
     }
     const result = this.metamaskConnectMultichain.invokeMethod(
@@ -1970,686 +2788,11 @@ walletInvokeMethod_fn = function(request) {
   });
 };
 
-// src/multichain/transports/mwp/index.ts
-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;
-  }
-  /**
-   * 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;
-      }
-    });
-  }
-  /**
-   * 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();
-    }
-  }
-  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;
-            }
-            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 : {}
-          );
-          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);
-      }
-    });
-  }
-  init() {
-    return __async(this, null, function* () {
-    });
-  }
-  // 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);
-      });
-    });
-  }
-  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);
-              dappClient.connect({
-                mode: "trusted",
-                initialPayload: {
-                  name: MULTICHAIN_PROVIDER_STREAM_NAME,
-                  data: request
-                }
-              }).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();
-      });
-    });
-  }
-  /**
-   * 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
-        }
-      });
-    });
-  }
-  /**
-   * Checks if the transport is connected
-   *
-   * @returns True if transport is connected, false otherwise
-   */
-  isConnected() {
-    return this.dappClient.state === "CONNECTED";
-  }
-  /**
-   * 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}`)
-        );
-      }
-    });
-  }
-  getCachedResponse(request) {
-    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
-          };
-        }
-      }
-    });
-  }
-  storeWalletSession(request, response) {
-    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);
-      }
-    });
-  }
-  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) => {
-        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);
-    return () => {
-      this.notificationCallbacks.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;
-      }
-    });
-  }
-  // 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]);
-    });
-  }
-};
-
-// src/multichain/transports/mwp/KeyManager.ts
-import { decrypt, encrypt, PrivateKey, PublicKey } from "eciesjs";
-var KeyManager = class {
-  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 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;
@@ -2667,7 +2810,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);
@@ -2677,6 +2820,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);
@@ -2713,12 +2857,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`,
@@ -2772,7 +2917,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."
@@ -2821,7 +2966,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 */);
@@ -2868,12 +3013,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);
         }
@@ -2883,13 +3029,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);
     });
@@ -2938,6 +3085,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();
@@ -2995,6 +3143,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)
@@ -3004,9 +3153,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)
@@ -3028,7 +3179,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 */);
@@ -3072,31 +3223,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)
@@ -3155,6 +3318,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";
@@ -3224,6 +3388,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();
@@ -3239,7 +3404,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) {
@@ -3250,6 +3415,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;
   });
@@ -3346,9 +3512,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);
@@ -3788,6 +3954,7 @@ export {
   StoreAdapter,
   StoreClient,
   TransportType,
+  classifyFailureReason,
   createLogger,
   createMultichainClient,
   enableDebug,